UM2L6——数组和Arrays类

本章代码关键字

import                        //向该文件导入某个包
java.util.Arrays            //Arrays类所在的包
Arrays.fill()                //填充数组
Arrays.sort()                //为数组排序，默认是升序排列
Arrays.copyOf()                //复制数组
Arrays.copyOfRange()        //复制数组的指定范围内内容
Arrays.binarySearch()        //查找数组内的某个元素，返回索引

数组

Java中的数组使用和C#中基本类似，区别是：

1. 数组的声明有些许区别
2. Java中的二维数组和交错数组的写法都是[][]​
   而C#中的 二维数组是[,]​，交错数组是[][]​

一维数组

相比于C#，Java的数组有两种声明方式，一种是[]​在变量类型后，另一种是[]​在变量名后，后者是沿袭自C/C++的声明方法
为了避免歧义，明确数组类型并与C/C++的写法作出区分，建议只使用第一种写法

int[] arr1;
int arr2[];

数组初始化有三种方法：

对于没有指定元素值的数组，其元素都是默认值，例如int​数组元素默认值就是0

1. ​new 数组类型[容量]​

   int[] arr1 = new int[5];
   int arr3[] = new int[3];

2. ​new 数组类型[]{内容}​

   通过大括号指定数组内元素的值时，不需要再在中括号内指定数组长度

   arr1 = new int[] { 1, 2, 3, 4 };

3. ​数组元素类型[] 数组名 = {内容}​

   注意，这种写法只能用于对刚开始声明的数组变量进行初始化，而不能对已经声明过的变量进行赋值

   // arr1 = {1, 2, 3, 4};            //注意，不能用于对已经声明的变量进行赋值
   int[] arr4 = { 1, 2, 3, 4 };    //该写法只能用于简化数组变量的声明

数组的遍历

使用for循环遍历数组有两种方式，一种是遍历索引的传统写法，另一种是类似于foreach​的写法

int[] arr4 = { 1, 2, 3, 4 };
for (int i = 0; i < arr4.length; i++) {
    System.out.println(arr4[i]);
}
System.out.println("**********");
for (int x : arr4) {
    System.out.println(x);
}

输出：

1
2
3
4
**********
1
2
3
4

二维数组

注意：Java中的二维数组写法和C#中交错数组一样

同样的java的数组有两种声明方式，一种是[][]​在变量类型后，另一种是[][]​在变量名后
为了避免歧义，明确数组类型，建议只使用第一种写法

int[][] arrays;
int arrays1[][];

二维数组初始化有三种方法：

对于没有指定元素值的数组，其元素都是默认值，例如int​数组元素默认值就是0

1. ​new 数组类型[行][列]​

   arrays = new int[3][2];

2. ​new 数组类型[][]{ {内容}, {内容} }​

   通过大括号指定数组内元素的值时，不需要再在中括号内指定数组长度

   arrays = new int[][] { {2, 1},
                          {1, 2},
                          {3, 2} };

3. ​数组元素类型[][] 数组名 = { {内容}, {内容} }​

   注意，这种写法只能用于对刚开始声明的数组变量进行初始化，而不能对已经声明过的变量进行赋值

   /* 注意，不能用于对已经声明的变量进行赋值
   arrays1 = { {2, 1},
               {1, 2},
               {3, 2} };
   */
   
   //该写法只能用于简化数组变量的声明
   int[][] arrays2 = { {2, 1},
                       {1, 2},
                       {3, 2} };

二维数组的遍历

使用for循环遍历数组有两种方式，一种是遍历索引的传统写法，另一种是类似于foreach​的写法

int[][] arrays2 = { {2, 1},
                    {1, 2},
                    {3, 2} };
for (int i = 0; i < arrays2.length; i++) {
    for (int j = 0; j < arrays2[i].length; j++) {
        System.out.println(arrays2[i][j]);
    }
}
System.out.println("**********");
for (int[] line: arrays2) {
    for (int x : line) {
        System.out.println(x);
    }
}

输出：

**********
2
1
1
2
3
2
**********
2
1
1
2
3
2

交错数组

注意：Java中交错数组使用和C#基本类似

交错数组的列数是不同的，因此在声明交错数组时，数组的列数可以不指定

int[][] arr10 = new int[3][];
arr10[0] = new int[] { 1, 2, 3 };
arr10[1] = new int[] { 1, 2 };
arr10[2] = new int[] { 1 };

int[][] arr11 = new int[][] { { 1, 2, 3 },
                              { 1, 2 },
                              { 1 } };

交错数组的遍历和二维数组的遍历方法是一致的

int[][] arr11 = new int[][] { { 1, 2, 3 },
                              { 1, 2 },
                              { 1 } };
System.out.println("**********");
for (int i = 0; i < arr11.length; i++) {
    for (int j = 0; j < arr11[i].length; j++) {
        System.out.println(arr11[i][j]);
    }
}
System.out.println("**********");
for (int[] line: arr11) {
    for (int x : line) {
        System.out.println(x);
    }
}

Arrays

​Arrays​类是Java提供的一个专门对数组进行操作的类
它提供了很多静态方法，共我们对数组进行处理，比如排序、查找、填充等等方法
使用它 需要导入java.util.Arrays​包（类似C#中的命名空间）

import java.util.Arrays;        //导入java.util.Arrays包

public class Lesson7 {
    public static void main(String[] args) {
        int[] arr = new int[5];
        for (int n : arr) {
            System.out.println(n);
        }
        Arrays.fill(arr, 5);
        System.out.println("**********");
        for (int n : arr) {
            System.out.println(n);
        }
    }
}

填充替换数组元素

​Arrays.fill​ 方法可以帮助我们对数组进行填充，它有两个重载

1. ​Arrays.fill(数组, 填充值)​

   它会替换数组内所有的值

   int[] arr = new int[5];
   for (int n : arr) {
       System.out.println(n);
   }
   Arrays.fill(arr, 5);
   System.out.println("**********");
   for (int n : arr) {
       System.out.println(n);
   }

   输出：

   0
   0
   0
   0
   0
   **********
   5
   5
   5
   5
   5

2. ​Arrays.fill(数组, 填充起始位置(包括), 填充结束位置(不包括), 填充值)​

   它可以在特定范围内填充数组元素，注意填充是左包含右不包含！
   第三个参数设计为不包含是方便我们直接传入数组长度这些消息

   System.out.println("**********");
   Arrays.fill(arr, 1, 4, 1);
   for (int n : arr) {
       System.out.println(n);
   }

   输出：

   **********
   5
   1
   1
   1
   5

数组排序

​Arrays.sort(数组)​方法可以对数组进行默认的升序排序

arr = new int[] { 4, 3, 6, 1, 2, 8 };
Arrays.sort(arr);
System.out.println("**********");
for (int n : arr) {
    System.out.println(n);
}

输出：

**********
1
2
3
4
6
8

复制数组

赋值数组有两种方法：

1. ​Arrays.copyOf(数组, 复制长度)​方法可以赋值指定数组的指定长度

   若复制长度小于传入数组，则截取；若复制长度大于传入数组，则用默认值填充，返回一个被复制出来的数组

   arr = new int[] { 1, 2, 3, 4, 6, 8 };
   int[] arr2 = Arrays.copyOf(arr, 3);
   System.out.println("**********");
   for (int n : arr2) {
       System.out.println(n);
   }
   arr2 = Arrays.copyOf(arr, 8);
   System.out.println("**********");
   for (int n : arr2) {
       System.out.println(n);
   }

   输出：

   **********
   1
   2
   3
   **********
   1
   2
   3
   4
   6
   8
   0
   0

2. ​Arrays.copyOfRange(数组, 开始复制索引(包括), 赋值的最后索引位置(不包括) )​

   该方法可以复制数组的指定部分，注意复制是左包含右不包含！

   arr = new int[] { 1, 2, 3, 4, 6, 8 };
   arr2 = Arrays.copyOfRange(arr, 1, 4);
   System.out.println("**********");
   for (int n : arr2) {
       System.out.println(n);
   }

   输出：

   **********
   2
   3
   4

查询数组

​Arrays.binarySearch(数组，搜索元素)​，该方法可以查询数组内的某个元素，
如果存在就会返回该元素的索引，如果不存在就会返回一个不确定的负数

注意：由于binarySearch内部是对数组进行二分查找，所以使用前必须对数组进行排序，
由于该方法是采用的二分查找，因此对于两个值相同的元素，返回的索引是不确定的

arr = new int[] { 4, 3, 6, 1, 2, 8, 1 };
System.out.println("**********");
Arrays.sort(arr);
int index = Arrays.binarySearch(arr, 5);
System.out.println(index);
index = Arrays.binarySearch(arr, 1);
System.out.println(index);
index = Arrays.binarySearch(arr, 2);
System.out.println(index);

输出：

**********
-6
1
2

该方法还有一个可在数组指定范围内查询值的重载

​Arrays.binarySearch(数组，开始索引(包括)，结束索引(不包括)，搜索元素)​，
该方法是在数组的指定范围内查找元素，注意复制是左包含右不包含的！ 、

arr = new int[] { 1, 1, 2, 3, 4, 6, 8 };
index = Arrays.binarySearch(arr, 1, 6, 1);
System.out.println(index);

输出：

1

‍