第六章 数组、排序和查找

一、数组（P156）

1. 数组介绍

数组可以存放多个同一类型的数据。数组也是一种数据类型，是 引用类型。

即：数(数据)组(一组)就是一组数据。

2. 数组的使用

2.1 使用方式1：动态初始化

数组的定义：

数据类型[] 数组名 = new 数据类型[大小];

public class Demo {
    public static void main(String[] args) {
        int[] a = new int[5];
    }
}

数组的引用（使用/访问/获取数组元素）：

数组名[下标/索引/index]

public class Demo {
    public static void main(String[] args) {
        int[] a = new int[5];
        int b = a[0];
    }
}

2.2 使用方式2：动态初始化

先 声明数组，再创建数组。

public class Demo {
    public static void main(String[] args) {
        int[] a;
        a = new int[5];
    }
}

2.3 使用方式3：静态初始化

数组的定义：

数据类型 数组名[] = {元素值，元素值…}

public class Demo {
    public static void main(String[] args) {
        int[] a = {1, 2, 3};
    }
}

3. 数组使用注意事项和细节

（1）数组是多个相同类型数据的组合，实现对这些数据的统一管理。

（2）数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。

（3）数组创建后，如果没有赋值，有默认值。
int 0，short 0，byte 0，long 0，float 0.0，double 0.0，char \u0000，boolean false，String null

（4）数组的下标是 从 0 开始的。

（5）数组下标必须在指定范围内使用，否则报：下标越界异常。

（6）数组属引用类型，数组型数据是对象(object)。

4. 数组赋值机制

1. 基本数据类型赋值，这个值就是具体的数据，而且相互不影响。赋值方式为 值传递/值拷贝。

2. 数组在默认情况下是 引用传递，赋的值是地址。

public class Demo {
    public static void main(String[] args) {
        // 基本数据类型赋值方式为值拷贝
        int n1 = 10;
        int n2 = n1;

        n2 = 80; // n2的变化不影响n1的值

        System.out.println(n1); // 10
        System.out.println(n2); // 80

        // 数组赋值方式为引用赋值
        int[] arr1 = {1,2,3};
        int[] arr2 = arr1;

        arr2[0] = 100; // 引用传递，arr2的变化会影响arr1

        System.out.println(arr1[0]);//100
    }
}

5. 数组拷贝

public class Demo {
    public static void main(String[] args) {

        //将 int[] arr1 = {10,20,30}; 拷贝到 arr2 数组
        //要求数据空间是独立的

        int[] arr1 = {10,20,30};

        int[] arr2 = new int[arr1.length];

        for(int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }

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

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

6. 数组反转

public class Demo {
    public static void main(String[] args) {

        //定义数组
        int[] arr = {11, 22, 33, 44, 55, 66, 77};

        int temp = 0;
        int len = arr.length;
        for (int i = 0; i < len / 2; i++) {
            temp = arr[len - 1 - i];
            arr[len - 1 - i] = arr[i];
            arr[i] = temp;
        }

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

public class Demo {
    public static void main(String[] args) {

        //定义数组
        int[] arr1 = {11, 22, 33, 44, 55, 66, 77};

        int[] arr2 = new int[arr1.length];

        for (int i = arr1.length - 1, j = 0; i >= 0; i--, j++) {
            arr2[j] = arr1[i];
        }

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

二、排序（P172）

排序是将多个数据，依指定的顺序进行排列的过程。

排序的分类：

（1）内部排序
指将需要处理的所有数据都加载到内部存储器中进行排序。包括（交换式排序法、选择式排序法和插入式排序法）

（2）外部排序法：
数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。包括（合并排序法和直接合并排序法）

三、冒泡排序法

冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从后向前（从下标较大的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。

思路：

public class Demo {
    public static void main(String[] args) {
        int[] array = {24, 69, 80, 57, 13, 100, -1};

        int max;
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    max = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = max;
                }
            }
        }

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

四、二维数组（P176）

二维数组的元素是一维数组

public class Demo {
    public static void main(String[] args) {

        // 使用方式 1: 动态初始化
        int[][] arr1 = new int[2][3];

        // 使用方式 2: 动态初始化
        // 先声明类型,再定义(开辟空间)
        int[][] arr2;
        arr2 = new int[2][3];

        // 使用方式 3: 动态初始化-列数不确定
        //如果没有给一维数组 new ,那么 arr[i]就是 null
        int[][] arr = new int[3][];
        
        // 使用方式 4: 静态初始化
        int[][] arr3 = {{1, 1, 1}, {8, 8, 9}, {100}};

    }
}