第六章 数组

数组是用来存储数据的集合，但是，通常我们会发现把数组看作一个存储具有相同类型 的变量集合会更有用。无须声明单个变量，例如：number0, number1,......... number99, 只要声明一个数组变量 numbers,并且用 numbers[0], numbers[1], .......numbers[99 ]来表示单个变量。

当给数组分配空间时，必须指定该数组能够存储的元素个数，从而确定数组大小。创 建数组之后就不能再修改它的大小。可以使用 arrayRefVar.length 得到数组的大小

当创建数组后，它的元素被賦予默认值，数值型基本数据类型的默认值为 0, char 型的 默认值为 AuOOOO’，boolean 型的默认值为 false。

一旦数组被创建，它的大小是固定的。使用一个數组引用变量，通过下标来访 问數组中的元素。

6.1 一维数组

定义数组

int[] matrix = {0,1,2,3,6,5};

访问数组

for(int i = 0; i < matrix.length; i++) {
    System.out.println(matrix[i]);
}

Java 支持一个简便的 for 循环，称为 foreach 循环，即不使用下标变量就可以顺序地遍 历整个数组。例如，下面的代码就可以显示数组 myList 的所有元素：

for (double e: myList) {

        System.out •println(e);

}

此代码可以读作 “ 对 myList 中每个元素 e 进行以下操作” 。注意，变量 e 必须声明为与 myList 中元素相同的数据类型。

数组复制

复制数组有三种方法：

        1 ) 使用循环语句逐个地复制数组的元素。

        2 ) 使用 System 类中的静态方法 arraycopy。

        3 )使用 clone 方法复制数组

int[] matrix1 = {2 , 3, 1, 5, 10};
int[] matrix2 = new int[matrix1.length]:
for Cint 1 - 0: i < matrix1.1enath: i++) {
    matrix2[i] = matrix1[i];
}

 数组的查找

①，线性查找法

线性査找法将要査找的关键字 key 与数组中的元素逐个进行比较。这个过程持续到在列 表中找到与关键字匹配的元素，或者査完列表也没有找到关键字为止。如果匹配成功，线性 査找法返回与关键字匹配的元素在数组中的下标。如果没有匹配成功，则返回 - 1。

public class LinearSearch {
    public static int 1inearSearch (int[] list, int key) {
        for (int i = 0;i < list.length;1++) {
            if (key == list[i])
            return i;
        }
        return -1;
   } 
}

②二分查找法

二分査找法是另一种常见的对数值列表的査找方法。使用二分査找法的前提条件是数组 中的元素必须已经排好序。假设数组已按升序排列。二分査找法首先将关键字与数组的中间 元素进行比较。

考虑下面三种情况：

• 如果关键字小于中间元素，只需要在数组的前一半元素中继续査找关键字。

• 如果关键字和中间元素相等，则匹配成功，査找结束。

• 如果关键字大于中间元素，只需要在数组的后一半元素中继续査找关键字。

 

public static int binarySearch(int[] list, int key) {
    int low = 0;
    int high = list.length - 1;
    int mid = (low +　high) / 2;
    if(key < list[mid]) {
        high = mid - 1;
    }else if (key == list[mid]) {
        return mid;    
    }else {
        low = mid + 1;
    }
}

数组的排序

冒泡排序

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {2,3,5,4,6,7,9,8,1};
        for(int i = 0; i < arr.length - 1; i++) {
            for(int j = 0; j < arr.length - 1; j++) {
                if(arr[j] > arr[j + 1]){
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        for(int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

插入排序

public class InsertSort {
    public static void main(String[] args) {
        int[] arr = {3,6,4,2,1,9,7,8,5};
            for (int i = 1; i < arr.length; i++) {
                for (int j = i; j > 0 && arr[j - 1] > arr[j]; j--) {
                    int temp = arr[j];
                    arr[j] = arr[j - 1];
                        arr[j - 1] = temp;
                }
            }
        for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
        }
    }
}

数组扩容

public class ShuZuKuoRong {
    public static void main(String[] args) {
        int[] arr = {5,6,7,89,8,1,23,2};
        arr = add(arr,8);
        for(int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        
    }
    public static int[] add(int[] arr, int e) {
        int[] newArr = new int[arr.length + 1];
        for(int i = 0; i < arr.length; i++) {
            newArr[i] = arr[i];
        }
        newArr[newArr.length - 1] = e;
        return newArr;
    }
}

 6.2 Arrays类

java.util.Arrays 类包括各种各样的静态方法，用于实现数组的排序和査找、数组的比 较和填充数组元素，以及返回数组的字符串表示。这些方法都有对所有基本类型的重载方法。

可以使用 sort 或者 parallelSort方法对整个数组或部分数组进行排序。例如，下面的 代码对数值型数组和字符型数组进行排序。

double[] numbers = {6.0, 4.4, 1.9, 2.9, 3.4, 3.5};
java.util.Arrays.sort(numbers);// Sort the whole array
java.util.Arrays.parallelSort(numbers): // Sort the whole array
//可以调用sort(numbers)对整个数组 numbers 排序。可以调用sort(chars，l, 3)对从chars[l]到 charS[3-l]的部分数组排序。


char[] chars = {'a* , 'F', 'D', 'P'};
java.util .Arrays.sort(chars, 1，3);// Sort part of the array
java.util .Arrays.parallelSortfchars, 1, 3); // Sort part of the array

可以采用二分査找法（ binarySearch 方法）在数组中査找关键字。数组必须提前按升序 排列好。如果数组中不存在关键字，方法返回 -( 插入点下标 +1)。

int[] list = {2 , 4, 7, 10, 11, 45 , 50 , 59, 60, 66 , 69, 70, 79 } ;
System.out.println("l. Index is " +java.util .Arrays.binarySearchflist, 11));
System.out.println("2. Index is " +java.util .Arrays.binarySearch(list, 12));

可以采用 equals 方法检测两个数组是否相等。如果它们的内容相同，那么这两个数组 相等。

int[] listl = {2 , 4 , 7, 10};
int[] list2 = {2 , 4 , 7 , 10};
int[] list3 = {4, 2 , 7 , 10}:
System.out.println(java.util.Arrays.equals(1istl, list2)); // true
System.out.println(java.util.Arrays.equals(1ist2 , 1ist3)); // false

可以使用 fill 方法填充整个数组或部分数组。

int[] listl = {2 , 4, 7, 10};
int[] list2= {2 , 4 , 7 , 7, 7, 10};
java.util.Arrays.fiil (list1, 5); // Fill 5 to the whole array
java.util.Arrays.fill(lisst2,1, 5, 8); // Fill 8 to a partial array
//可以使用 fill 方法填充整个数组或部分数组。例如：下列代码将 5 填充到 listl 中，将 8 填充到元素 list2[l] 到 list2 [5-l] 中。

 可以使用 toString 方法来返回一个字符串，该字符串代表了数组中的所有元素。这 是一个显示数组中所有元素的快捷和简便的方法。

int[] list = {2 f 4, 7, 10};
System.out.println(Arrays.toString(list));
//显示 [ 2 , 4 , 7, 10]。

 6.3 多维数组

6.3.1二维数组

下面是声明二维数组的语法：

数据类型[ ][ ]  数组名;

或者

数据类型 数组名 [ ][ ];

int[][] matrix;
int matrix[][];// 允许这种方式 ，但并不推荐使用它

 获取二维数组的长度

二维数组实际上是一个数组，它的每个元素都是一个一维数组。数组 X 的长度是数组中 元素的个数，可以用 x.length 获取该值。元素 x[0], x[l], … ，x[x.lengthl]也是数组。 可以使用 x[0].length, x[l].length, …，x[x.length1].length 获取它们的长度。

锯齿数组

二维数组中的每一行本身就是一个数组，因此，各行的长度就可以不同。这样的数组称为锯齿数组（ragged array)。

int[][] triangleArray = {
    {1, 2 , 3 , 4 t 5},
    {2. 3, 4 . 5},
    {3. 4 , 5},
    {4 , 5},
    {5}
};

 循环使用用户输人值初始化数组:

java.util.Scanner input = new Scanner(System.in);
System.out.println("enter" + matrix.length + "rows and" + matrix[0].length + " columns: ");
for(int row = 0; row <　matrix .length; row++) {
    for(int column = 0; column < matrix[row].length; colum++) {
        matrix[row][column] = input.nextInt();
    }
}

循环使用 0 到 99 之间的随机值初始化数组:

for (int row * 0; row < matrix.length; row++){
    for (int column = 0; column < matrix[row].length; column++){
        matrix[row][column] = (int)(Math.random() * 100);
    }
}

为打印一个二维数组，必须使用如下所示的循环打印数组中的每个元素:

for (int row ■ 0; row < matrix.length; row++){
    for (int column = 0; column < matrix[row].length; column++){
        System.out.print(matrix[row][column] + " " );
    }
    System.out.println();
}

传递二维数组

import java.util.Scanner;

public static PassTwoDimensionalArray {
    public static void main(String[] args) {
        int[][] = getArray();
        System.out.println(sum(m));
    }
    public static int[][] getArray() {
        Scanner scanner = new Scanner(System.in);
        int[][] m = new int[3][4];
        for(int i = 0; i < m.length; i++) {
            for(int j = 0; j < m[i].length; j++) {
                m[i][j] = input.nextInt();
            }
        }
        return m;
    }
    public static int sum(int[][] m) {
        int total = 0;
        for(int row = 0; row < m.length; row++) {
            for(int column = 0; column < m[row].length; column+) {
                total += m[row][column];
            }
        }
        return total;
    }
}