java数组[]使用

1. 定义

• 概念: 一组相同对象的集合
• 新建及初始化

1) 一维数组

int[] a   = new int[5];  //定义5个整型变量
int[] a1 = new int[]{8,22,15,19,33}; //定义5个变量，并赋值   
int[] a2 = {8,22,15,19,33}; //定义5个变量赋值的简写

2) 二维数组

int[][] b = new int[5][];  //定义了一维的长度
int[][] b1 = new int[5][5]; //定义一维和二维的长度
int[][] b2 = new int[][] { { 1, 2 } }; //初始一维的数据
int[][] b3 = new int[][] { { 1, 2 }, { 3, 4 ,5} }; //初始长度为2的二维数据

3） 多维数组

int[][][] c = new int[2][3][4]; //一个三维数组

2. 取值&赋值

• 基本原则：一般情况下可以取到某个位置的值，那就可以给这个位置赋值。
• 常用赋值

//一维数组赋值
int[] a   = new int[5];
a[2] = 5; //注意这里的下标不能越界
//二维数组赋值
int[][] b = new int[5][];
b[0] = new int[3]; //这里我们需要把二维的数组先定义出来
b[0][1] = 3;
b1[2][2] = 5; //这里已经定义出来的，就可以直接赋值了
//多维数组赋值法类似
c[0][0][0] = 8;

• 工具方法赋值

// 1.用已有数组生成新数组
int[] bNew = Arrays.copyOf(a1, 4);
System.out.println(Arrays.toString(bNew));
//[8, 15, 19, 22]

// 2. 复制指定范围的数据，生成新数组
int[] bNew1 = Arrays.copyOfRange(a1, 2, 3);
System.out.println(Arrays.toString(bNew1));
//[19]

// 3. 将数组更新为同一个值
Arrays.fill(bNew, 20);
System.out.println(Arrays.toString(bNew));
//[20, 20, 20, 20]

//4. 指定范围更新为同一个值
Arrays.fill(bNew, 2,4, 20);
System.out.println(Arrays.toString(bNew));
//[8, 15, 20, 20]

3. 遍历

//一维数组
int[] a1 = new int[]{8,22,15,19,33};
for(int i=0;i<a1.length;i++) {
    System.out.print(a1[i] + " ");
}
System.out.println();

//二维数组
int[][] b3 = new int[][] { { 1, 2 }, { 3, 4 ,5} };
for(int i=0;i<b3.length;i++) {
    for(int j=0;j<b3[i].length;j++) {
        System.out.print(b3[i][j] + " ");
    }
    System.out.println(); //换行显示
}
//多维数组，就分多层嵌套循环就可以

//简单输出数组
System.out.println(Arrays.toString(a1));
//[8, 22, 15, 19, 33]

4. 排序

为方便后面的数据搜索，我们需要对数组先进行排序。

• 原始数据

int a1 = new int[] { 8, 22, 15, 19, 33};

• 正常排序

Arrays.sort(a1); //排序
System.out.println(Arrays.toString(a1)); //排序后输出
//[8, 15, 19, 22, 33]

• 指定位置排序

a1 = new int[] { 8, 22, 15, 19, 33};
Arrays.sort(a1,1,3); //注意下标，并不包括结尾的下标3位置
System.out.println(Arrays.toString(a1));
//[8, 15, 22, 19, 33]

• 并行排序

a1 = new int[] { 8, 22, 15, 19, 33};
Arrays.parallelSort(a1,1,5);
System.out.println(Arrays.toString(a1));
//[8, 15, 19, 22, 33]

注：一般经验，数组大小在10多万的情况下达到平衡点，
在这个数量以下sort排序快一点，更多数量的情况下parallelSort更快一点,
具体的平衡点，会随着机器配置变化而变化。

5. 查找

• 全局搜索

int a1 = new int[] { 8, 22, 15, 19, 33};
Arrays.sort(a1);
int index = Arrays.binarySearch(a1, 15);
System.out.println(index);
//1

• 按位置搜索

index = Arrays.binarySearch(a1, 1, 3, 19); //注意，这里也不包括下标为3的位置
System.out.println(index);
//2

5. 比较

int[] b11 = {1,2,4};
int[] b12 = {1,2,5};
System.out.println(Arrays.equals(b11, b12));
//false

注：这里需要数组长度，和元素都相等才会相等。