JavaSE_Java

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

第一节:初识数组
- 1.数组的引入
- 2.数组的基本语法
- - 数组的属性和使用细节
- 3.数组的内存特征
- 4.数组的遍历方式
- - for循环遍历
  - foreach循环
第二节:数组的应用
- 1.查找数组中的极值及索引
- 2.查找数组中元素的索引
- 3.数组的扩容(增加元素)
- 4.数组的缩容(删除元素)
第三节:数组工具类的使用
- 1.Arrays工具类
- 2.数组的复制操作
第四节:数组的排序
- 1.冒泡排序
第五节:二维数组的使用(了解)
- 1.二维数组的初识
- 2.二维数组的遍历
- 3.二维数组的动态创建
- 4.二维数组存储数据

第一节:初识数组 1.数组的引入

数组可以解决哪些问题？

大量实际含义相同或者相近的数据需要存储在程序中
需要大量变量的命名
大量数据在程序的各个模块中如何传递

什么是数组？

数组其实就是将大量含义相同或者含义相近的数组放在一起组成一个整体
这些数据可以使用同一个标识符

package com.shiazene.knoeledge;

public class Myaapro01_初识数组 {
    public static void main(String[] args) {
        
        int [] chinese = {90,80,80,94,24,64,45,89,89,45,78,46,21};

    }
}

2.数组的基本语法

java中的数据类型：
基本数据类型：byte short int char long float double boolean
引用类型：数组 String

数组的创建：

静态创建：
1. 语法1：数据类型[] 数组名 = {元素1，元素2，元素3};
2. 语法1：数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3};
3. 数组的一个个元素组成一个数据
4. 数组中的元素类型都是相同或者相近的

package com.shiazene.knoeledge;

public class MyPro02_数组的创建 {
    public static void main(String[] args) {
        //静态创建
        int[] array1 = {12,34,56,345,21,3,234,13};
        int[] array2 = new int[]{12,34,56,345,21,3,234,13}; 
    }
}

动态创建
1. 语法：数据类型[] 数组名 = new 数据类型[数组的长度];
2. 数组的长度：数组中的元素个数

package com.shiazene.knoeledge;

public class MyPro02_数组的创建 {
    public static void main(String[] args) { 
        //动态创建
        int[] array3 = new int[5];
    }
    
}

数组的属性和使用细节

如何取出数组中的数据呢？
答案：利用数组中的索引机制
多个数据使用同一个标识符那么我们怎么区分数据是哪个?
答案：个数据虽然使用同一个标识符但是每个数据默认都有自己的编号

索引的定义：索引由数组自动生成并维护默认第一个元素的索引为0 后面的索引依次递增
索引的注意事项：
a. 索引本身是整数int类型
b.获取数组中的元素我们可以通过数组名配合索引来处理

尤其注意：
1.注意索引的大小不要超过最大值，也不能是负数
2.如果索引太大了或者是负数会出现：ArrayIndexOutOfBoundsException索引越界异常

获取数组中某个元素的值：数组名[索引值]

package com.shiazene.knoeledge;

public class MyPro03_数组的索引 {
    public static void main(String[] args) {
        //静态创建一个数组
        int[] array = {56,85,14,23,76,95,82,30};
        //获取数组中的元素
        System.out.println(array[6]);
        //取出元素给其他变量赋值
        int value = array[6];
        System.out.println(value);
        //修改数组中的元素
        array[2] = 99;
        System.out.println(array[2]);

        //如何确定索引的范围
        
        int l = array.length;
        System.out.println(l);
    }
}

3.数组的内存特征

基本数据类型创建的变量 ,存储在栈内存中 ,占用一块内存是方法中的内部的局部的变量数据量比较小一种临时的使用
引用类型的数据创建的变量存储在堆内存上栈内存引用堆内存上得地址占用两块内存,不仅仅是当前方法使用的范围更大的数据数据量比较大
一种持久性的存储

注意：
1.数组一旦创建其元素的值可以更改长度是不可改变的
2.数组存储数据增加和删除数据比较麻烦但是根据索引查询数据非常快的

4.数组的遍历方式 for循环遍历

package com.shiazene.knoeledge;

public class MyPro04_数组的遍历 {
    public static void main(String[] args) {
        //定义一个数组
        int[] array = {11,22,33,44,55,66,77,88,99};
        //遍历数组的本质：将数组中的每个元素都拿出来
        //使用for循环遍历
        for (int index= 0; index < array.length; index++) {
            System.out.println(array[index]);
        }
    }
}

foreach循环

foreach循环：针对于数组的增强型for循环遍历
简化for循环
foreach循环的语法：for(数据类型临时变量名：数组名){}
缺点：foreach循环没有办法通过中间变量修改数组元素
优点：
1. foreach循环在写法上更为简单
2. foreach循环没有索引
3. foreach循环通过索引查询元素，在循环内部通过索引修改元素（修改数组中的元素必须要借助索引）

当不需要使用数组索引，也不需要修改数组元素，首选foreach

package com.shiazene.knoeledge;

public class MyPro04_数组的遍历 {
    public static void main(String[] args) {
        //定义一个数组
        int[] array = {11,22,33,44,55,66,77,88,99};
        //遍历数组的本质：将数组中的每个元素都拿出来
        //使用foreach循环
        for (int x:array) {
            System.out.println(x);
        }
    }
}

第二节:数组的应用 1.查找数组中的极值及索引

示例1: 从键盘中录入10考试分数 56 12 32 89 78 95 54 19 91 88 输出最高分及最高分输入的序号

package com.shiazene.test;

import java.util.Arrays;
import java.util.Scanner;

public class MyPro01_输出最高分及序号 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] scores = new int[10];
        //利用for循环从键盘录入学生成绩
        for (int i = 0; i < scores.length; i++) {
            System.out.println("请输入第：" + (i+1)+"个学生成绩");
            scores[i] = sc.nextInt();
        }
        System.out.println("scores数组为："+Arrays.toString(scores));
        Arrays.sort(scores);
        System.out.println("scores的排序为："+Arrays.toString(scores));
        //获取数组中的最高分(打擂机制)
        int max = scores[0];
        //获取最大值的索引
        int maxindex =0;
        for (int i = 0; i < scores.length; i++) {
            if (max <= scores[i]){
                max = scores[i];
                maxindex = i;
            }
        }
        System.out.println("最高分为" + max);
        System.out.println("最高分是第"+(maxindex + 1) +"次输入的");
    }
}

2.查找数组中元素的索引

查找元素在数组中第一次，和最后一次在数组中出现的位置

 package com.shiazene.test;

public class MyPro02_查找数组中的索引 {
    public static void main(String[] args) {
        int[] arrays = {11,22,33,11,44,55,66,11,77,88,11};
        int value = 11;//要查找的元素为11
        int index = 0;//用于存储目标元素的索引
        //查找元素第一次在数组中出现的索引
        for (int i = 0; i < arrays.length; i++) {
            if (arrays[i] == value){
                index = i;
                break;//一定要跳出本次循环，不然出现循环继续，输出结果为最后一次出现的位置
            }
        }
        System.out.println("数组中第一次出现11的位置的索引为："+ index);
        //查找元素最后一次在数组中出现的索引
        int index2 = 0;
        for (int i = arrays.length-1; i >=0 ; i--) {
            if (arrays[i] == value){
                index2 = i;
                break;//一定要跳出本次循环，不然出现循环继续，输出结果为最后一次出现的位置
            }
        }
        System.out.println("数组中最后一次出现11的位置的索引为："+ index2);
        

        //判断一个数组中是否有且只有一个指定元素
        System.out.println(index == index2 && index >=0);
    }
}

3.数组的扩容(增加元素)

        需求: 将如下两个数组合并成一个数组
                 Int[] a={1,2,3,4,5,6,7,8,9}
                 Int[] b{11,22,33,44,55,66,77,88,99}

package com.shiazene.test;

import java.util.Arrays;

public class MyPro03_数组扩容 {
    public static void main(String[] args) {
        
        int[] array1 = {1,2,3,4,5,6,7,8,9};
        int[] array2 = {11,22,33,44,55,66,77,88,99};
        //将两个数组合并成一个数组
        //动态创建数组
        int[] arrays3 = new int[array1.length+ array2.length];
        //数组的遍历array1的值赋值进去
        for (int i = 0; i < array1.length; i++) {
            arrays3[i] = array1[i];
        }
        for (int i = (array1.length); i < (array1.length+ array2.length) ; i++) {
            arrays3[i] = array2[i- (array1.length)];
        }

        System.out.println(Arrays.toString(arrays3));
    }
}

数组的长度是不可变的如果数组装满了还想装更多的数据那么只能创建新数组将原有的数据和新增的数据都放在新数组中当数据转移完毕那么原来的数组就可以不要了

package com.shiazene.test;
import java.util.Arrays;
public class MyPro04_数组增加一个元素 {
    public static void main(String[] args) {
        //创建一个数组 在数组最后追加一个元素9
        int[] array = {1,2,3,4,5,6,7,8};
        //动态创建一个新数组
        int[] array2=new int[array.length+1];
        for (int i = 0; i < array.length; i++) {
            array2[i]=array[i];
        }
        array2[array.length] = 9;
        System.out.println(Arrays.toString(array2));
    }
}

        有如下数组
                int[] arr={5,7,6,10,4,2,3,1,8,9}
                在arr数组中索引为3 的位置插入一个元素 10
                在arr数组中索引为x 的位置插入一个元素 n

package com.shiazene.test;

import java.util.Arrays;

public class MyPro05_数组任意位置添加元素 {
    public static void main(String[] args) {
        //给定一个数组
        int[] arr={5,7,6,10,4,2,3,1,8,9};
        //在索引为3的位置加如100
        int[] array = new int[arr.length+1];
        //插入的索引之前的数据
        for (int i = 0; i < 3; i++) {
            array[i] = arr[i];
        }
        //插入的索引之前的数据
        array[3] = 100;
        for (int i = 4; i < array.length; i++) {
            array[i] = arr[i-1];
        }
        System.out.println(Arrays.toString(array));
    }
}

4.数组的缩容(删除元素)

int[] arr={5,9,7,3,4,6,8,2,1,0}
删除数组中索引为6的元素

import java.util.Arrays;

public class MyPro6_数组的缩容2 {
    public static void main(String[] args) {
        //给定指定数组
        int[] arr={5,9,7,3,4,6,8,2,1,0};
        //删除索引为6的元素
        for (int i = 6; i < arr.length-1; i++) {
            arr[i]=arr[i+1];
        }
        System.out.println(Arrays.toString(arr));
    }
}

package com.shiazene.test;

import java.util.Arrays;

public class MyPro04_数组的缩容 {
    public static void main(String[] args) {
        int[] arr={5,9,7,3,4,6,8,2,1,0};
        //创建一个新数组 删除 索引为6的数组
        int[] array = new int[arr.length-1];
        //遍历数组，将索引6之前的数组移进新的数组
        for (int i = 0; i < 6; i++) {
            array[i] = arr[i];
        }
        //将索引为6之后的arr数组移进array数组
        for (int i = 6; i < array.length; i++) {
            array[i] = arr[i+1];
        }
        System.out.println(Arrays.toString(array));
    }
}

数组存储数据的特点:
        数组的数据在内存上是连续
        根据索引查询数据快
         面对数据的增加和删除需要大量移动元素或者重新创建数组
        一般经常修改或者查询,但是基本不会增加和删除的数据适合使用数组存储

练习：
int[] arr={12,4,5,6,85,54,74,95,65,82,26,34};
将上述数组中的奇数和偶数分别存放于不同的两个数组

package com.shiazene.test;

import java.util.Arrays;

public class MyPro07_数组奇偶分开 {
    public static void main(String[] args) {
        //给定指定数组
        int[] arr={12,4,5,6,85,54,74,95,65,82,26,34};
        int x = 0;
        //计算偶数有多少个，奇数有多少个
        for (int i : arr) {
            if (i % 2 ==0){
                x++;
            }
        }
        //动态创建两个数组
        int[] array1 = new int[x];//偶数数组
        int[] array2 = new int[arr.length-x];//奇数数组
        int num1 = 0;//偶数数组的索引
        int num2 = 0;//偶数数组的索引
        //遍历arr数组，通过if—else将数组赋值
            for (int j : arr) {
                if (j % 2 == 0){
                   array1[num1] = j;
                   num1++;
                }else{
                    array2[num2] =j;
                    num2++;
                }
            }
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));

    }
}

第三节:数组工具类的使用 1.Arrays工具类

1. Arrays JRE中java基本类库提供的一个数组工具类

封装了一些排序查找极值遍历输出等操作
2. Arrays.sort(数组名)：数组的排序功能（升序）
3. Arrays.binarySearch(要查询的数组名称,数值)：查询元素
1. 在数组中快速的查询给定元素出现的位置
2. 如果找到元素返回元素索引没找到返回一个负数
3. 在使用时,要求数组必须是升序的
4. Arrays.toString(数组名)：快速的遍历数组，返回给定数组的字符串表达形式
5. Arrays.copyOf(要复制的数组名,要复制数组的长度);

package com.shiazene.knoeledge;

import java.util.Arrays;

public class MyPro05_数组工具类 {

public static void main(String[] args) {
        //给定指定数组
        int[] arr={12,4,5,6,85,54,74,95,65,82,26,34};
        System.out.println(Arrays.toString(arr));

        // 排序功能
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        //Arrays.binarySearch(要查询的数组名,数值);
        int index=Arrays.binarySearch(arr,26);
        System.out.println(index);

        
        String arrs= Arrays.toString(arr);
        System.out.println(arrs);
        
        //获得数组副本
        int[] arr1={1,2,3,4,5,6};
        // 将arr1存储的引用地址复制给arr2
        //int[] arr2=arr1;
        int[] arr2=Arrays.copyOf(arr1,arr1.length);
        arr1[0]=100;
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(arr2));
        }

}

2.数组的复制操作

格式：System.arraycopy(复制原数组名，要复制的起始索引，复制的新数组名，要复制到新数组的起始索引，新数组的元素长度)

src: 源数组要复制的数组
srcPos : 起始索引从源数组中的那个索引开始复制
dest : 目标数组数据复制到那个数组
destPost: 目标索引目标数组中从哪里开始复制
length: 数据长长度复制多少个元素

 package com.shiazene.knoeledge;

import java.util.Arrays;

public class MyPro06_数组的复制 {
    public static void main(String[] args) {
        int[] array1 = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
        int[] array2 = new int[10];
        System.arraycopy(array1,9,array2,1,5);
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
    }
}

Arrays.copyOf和System.arraycopy区别：
Arrays.copyOf的功能内部就是使用System.arraycopy的方法实现的 Arrays.copyOf起始就是对System.arraycopy 一个简化的封装

第四节:数组的排序 1.冒泡排序

从第一个元素开始，一次对比相邻的两个元素，如果发现前面的元素比后面的元素大，那么进行位置的互换
第一轮比互换结束，能够保证最大的元素一定在倒数第一位
第二轮比互换结束，能够保证最大的元素一定在倒数第二位

……

第n轮

package com.shiazene.knoeledge;

import java.util.Arrays;

public class MyPro07_冒泡排序 {
    public static void main(String[] args) {
        int[] arrays = {5,4,3,6,9,1,8,7,2};
        //数组的升序排列
        //控制对比互换执行的轮数
        for (int j = 0; j < arrays.length - 1; j++) {
            //完成一轮元素对比互换
            for (int i = 0; i < arrays.length - 1 - j; i++) {
                //如果发现前面的元素比后面的大，则前后位置互换
                if(arrays[i] > arrays[i+1]){
                    int temp = arrays[i];
                    arrays[i] = arrays[i+1];
                    arrays[i+1] = temp;
                }
            }
            System.out.println(Arrays.toString(arrays));
        }
    }
}

练习1: 从键盘录入学生人数和每个学生的分数按分数降序输出所有分数

package com.shiazene.test;
  import java.util.Arrays;
  import java.util.Scanner;
  public class MyPro08_数组的降序 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请录入学生人数");
        int num =sc.nextInt();
        // 准备一个数组存储多个学生分数
        int[] scores=new int[num];
        
        for (int i = 0; i  
练习2：从键盘录入学生人数和每个学生的姓名以及分数 按照分数降序输出 学生名次 学生               姓名 学生分数
               张              三 10
               李四 5
               王五 8
               赵六 7 
              第一名 张三 10分
               第二名 … …
           
 
package com.shiazene.test;
  import java.util.Arrays;
  import java.util.Scanner;
  public class Mypro09_数组的分数降序 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请录入学生人数");
        int num =sc.nextInt();
        // 准备一个数组存储多个学生分数
        int[] scores=new int[num];
        // 准备一个数组存储多个学生名字
        String[] names =new String[num];
        
        for (int i = 0; i  
第五节:二维数组的使用(了解) 
1.二维数组的初识 
什么是二维数组
 
  
2.二维数组的遍历 
二维数组：数组作为元素类型的数组 数组的数组
 
package com.shiazene.knoeledge;

public class MyPro08_二维数组 {
    public static void main(String[] args) {
        int[][] array = {{1,2,3},{4,5},{6,7,8,9}};
        //从数组中取出最小数据
        for (int i = 0; i < array.length; i++) {
            //从每个数组中取出元素
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]+"t");
            }
            System.out.println();
        }
             //foreach遍历
        for (int[] x : array) {
            for ( int i : x)  {
                System.out.print(i + "t");
            }
            System.out.println();
        }
    }
}
 
 
 for循环既可以遍历 可以修改元素值
 foreach 只能遍历 不能修改元素值 
 
3.二维数组的动态创建 
静态创建 
int[][] array = {{1,2,3},{4,5},{6,7,8,9}};
 
动态创建 
int[][]array = new int[外围数组长度][内围小数组的长度]
 
package com.shiazene.test;

import java.util.Scanner;
  public class MyPro10_数组的存储数据 {
    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        System.out.println("请录入学生人数");
        int r=sc.nextInt();
        System.out.println("请录入考试科目数");
        int k =sc.nextInt();
        int[][] grade=new int[r][k];
        // 录入分数的过程
        
        for (int i = 0; i  grade[i][j]) {
                    min=grade[i][j];
                }
            }
            System.out.println("第"+(i+1)+"个学生的总分为:"+sum+"t最高分:"+max+"t为最低分:"+min+"t为平均分为:"+(sum*1.0/k));
        }
        sc.close();
    }
}
  
 
4.二维数组存储数据 
从键盘录入学生人数 考试科目数 以及每个学生的每科分数
 输出每个学生的最高分 最低分 总分 平均分

JavaSE

Java相关栏目本月热门文章