三、数组

1、声明： 数组元素类型 数组名[]　　　　int arr[];

　　　　　数组元素类型[] 数组名　　　　String[] arg;

2、分配内存空间：数组名称 = new 数组元素类型[数组元素的个数];　　arr = new int[5];

3、初始化：int arr[] = new int[]{1,2,3,4,5};

　　　　　  int arr2[] = {1,2,3,4,5};

4、数组的基本操作

（1）遍历数组：for循环、foreach语句

（2）替换数组元素：Arrays类的静态方法fill（）

（3）排序：Arrays类的静态方法sort（）

（4）复制：Arrays类的方法copyOf（）、copyOfRange（）

5.插入排序法：将要排序的值逐个插入到其所适合的位置，其后的元素都向后移一个位置。

public class Test1 {
    public static void main(String[] args) {
        /*
         * 1. 产生一个乱序数组赋给 a
         * 2. 显示 a 数组
         * 3. 对 a 数组排序
         * 4. 显示 a 数组
         */
        int[] a = random();
        System.out.println(Arrays.toString(a));
        System.out.println("---------------------");
        sort(a);
        System.out.println("---------------------");
        System.out.println(Arrays.toString(a));
        
    }

    private static int[] random() {
        /*
         * 1. 随机产生一个数组长度赋给 len
         *        长度范围 [5, 11)
         * 2. 新建 len 长度的数组赋给 a
         * 3. 循环 i 从 0 到 <len 递增    
         *         4. 在a数组的i位置，
         *             放入一个100内的随机值
         * 5. 返回数组 a
         */
        
        int len = 
         5 + new Random().nextInt(6);
        int[] a = new int[len];
        for(int i=0;i<len;i++) {
            a[i] = new Random().nextInt(100);
        }
        return a;
    }

    private static void sort(int[] a) {
        /*
         * 1. 循环 i 从 1 到 <a.length 递增
         *         2. 循环 j 从 i-1 到 >=0 递减
         *             3. 如果 a[j+1] < a[j]
         *                 交换两个位置的值
         *             4. 否则，break
         *         5. 打印数组 a
         */
        
        // 第一个值，认为是有序数字序列
        for(int i=1;i<a.length;i++) {
            // j循环，将i位置的值，向前插入
            for(int j=i-1;j>=0;j--) {
                if(a[j+1] < a[j]) {
                    int t = a[j+1];
                    a[j+1] = a[j];
                    a[j] = t;
                } else {
                    break;
                }
            }
            System.out.println(Arrays.toString(a));
        }
    }
}

   冒泡排序法：对比相邻的元素值，满足条件则交换，把较小的元素移动到数组的前面，较大的移动到数组的后面。

public class Test1 {
    public static void main(String[] args) {
        /*
         * 1. 产生一个乱序数组赋给 a
         * 2. 显示 a 数组
         * 3. 对 a 数组排序
         * 4. 显示 a 数组
         */
        int[] a = random();
        System.out.println(Arrays.toString(a));
        System.out.println("---------------------");
        sort(a);
        System.out.println("---------------------");
        System.out.println(Arrays.toString(a));
        
    }

    private static int[] random() {
        /*
         * 1. 随机产生一个数组长度赋给 len
         *        长度范围 [5, 11)
         * 2. 新建 len 长度的数组赋给 a
         * 3. 循环 i 从 0 到 <len 递增    
         *         4. 在a数组的i位置，
         *             放入一个100内的随机值
         * 5. 返回数组 a
         */
        
        int len = 
         5 + new Random().nextInt(6);
        int[] a = new int[len];
        for(int i=0;i<len;i++) {
            a[i] = new Random().nextInt(100);
        }
        return a;
    }

    private static void sort(int[] a) {
        /*
         * 1. 循环 i 从 0 到 <a.length 递增
         *         2. 循环 j 从 a.length-1 到 >i 递减
         *             3. 如果 a[j] < a[j-1]
         *                 4. 两个位置的值交换
         *         5. 打印数组 a
         *             
         */
        
        for(int i=0;i<a.length;i++) {
            // j循环，将最小值推到 i 位置
            boolean flag = false;//还没有交换
            for(int j=a.length-1;j>i;j--) {
                if(a[j] < a[j-1]) {
                    int t = a[j];
                    a[j] = a[j-1];
                    a[j-1] = t;
                    flag = true;//如果交换，flag置成true
                }
            }
            if(! flag) {
                // flag的值还是 false，没有交换
                // 排序完成
                break;
            }
            
            System.out.println(Arrays.toString(a));
        }
    }
}