什么是数组

数组是相同类型数据的有序集合
每一个数据成为一个数组元素，通过数组下标访问
数组长度是确定的，一旦确定长度便无法改变

数组的声明和创建

声明语法：

1.数组类型 [] 数组名
2.数组类型  数组名[]

public static void main(String[] args) {
    /*第一种声明语法*/
    int[] first;
    /*第二种声明语法*/
    int first1[];
}

推荐使用第一种，第二种是C/C++里面的语法，第二种最初是为了让程序员快速适应Java语言而采用的。

创建语法：

public class Array01 {
    public static void main(String[] args) {
        /*第一种声明语法*/
        int[] first0; 
        /*创建语法， 数据类型[] 数组名=new 数据类型[数组长度]*/
        int[] first1=new int[15];
        /*第二种声明语法*/
        int first2[];
        /*第二种创建语法*/
        first0 = new int[5];
        /*  first[0]=1;
         * 若不赋值，会输出默认值
         */
        first0[1] = 1;
        first0[2] = 2;
        first0[3] = 3;
        first0[4] = 4;
        System.out.println(first0[0]);//没有赋值输出默认值0
        System.out.println(first0[1]);
        System.out.println(first0.length);//获取数组长度

    }
}

数组分配时的内存分析

public class Array01 {
        public static void main(String[] args) {
            int []array;
            int[] array=new int[5];
            /*  first[0]=1;
             * 若不赋值，会输出默认值
             */
            first0[1] = 1;
            first0[2] = 2;
            first0[3] = 3;
            first0[4] = 4;
        }
    }

以上述代码为例分析内存分配

当执行声明语句时，会在栈中创建一个array，但是并没有赋值，堆中也没有产生任何东西。
当执行创建语句之后，在堆中开辟了一个区域，区域内数组创建个数对应的空间，若没有赋值则会隐性赋值为默认值。

数组的使用

public class Array02 {
    public static void main(String[] args) {
        int array[]= {1,2,3,4,5};
        /*输出所有数组元素*/
        for (int i = 0; i < 5; i++) {
            System.out.println(array[i]);
        }
        /*输出数组元素中的最大值*/
        int max=array[0];
        for (int i = 0; i < 5; i++) {

            if (array[i]>max){
                max=array[i];
            }
        }
        System.out.println(max);
        /*输出数组元素相加的和*/
        int sum=0;
        for (int i = 0; i < 5; i++) {
            sum+=array[i];
        }
        System.out.println(sum);
        }
}

多维数组

本质上是数组再嵌套数组

int [][] array={{1,2}，{3,4}};

此时
array [0] [0]=1
array[0]=1,2

Arrays类

API为我们提供了一个Arrays的类，包含了数组的各种方法，包括排序和搜索等。
Arrays常用的方法：
我们自己也可以写方法，只不过我们没有必要重复造轮子
1.toString方法：输出数组元素

public class Array03 {
    public static void main(String[] args) {
        int[] a={1,2,325,252346,234215,323451,25345};
        System.out.println(Arrays.toString(a));
    }
}

2.sort方法：升序排序
先排序，再输出

public class Array03 {
    public static void main(String[] args) {
        int[] a={1,2,325,252346,234215,323451,25345};
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

3.fill方法：数组填充

public class Array03 {
    public static void main(String[] args) {
        int[] a={1,2,325,252346,234215,323451,25345};
        Arrays.sort(a);
        Arrays.fill(a,0);//填充值为0
        System.out.println(Arrays.toString(a));
    }
}

冒泡排序

冒泡排序是比较出名的一种算法，也比较简单，有两层循环，外层冒泡轮数，里层依次比较，算法时间复杂度为O(n^2)
核心就是比较数组中相邻的元素，如果第一个数比第二个大那就交换位置。
每次都会产生一个最大最小数，依次循环，实现排序。

public class Arrays04 {
    public static void main(String[] args) {
        int temp = 0;
        int[] a = {5, 4, 3, 2, 9};
        for (int i = 0; i < a.length - 1; i++) {
 
            for (int j = 0; j < a.length-1-i; j++) {
                if (a[j + 1] < a[j]) {
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j+1]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

思路：依次比较相邻的两个数，将比较小的数放在前面，比较大的数放在后面。

　　　　(1)第一次比较：首先比较第一和第二个数，将小数放在前面，将大数放在后面。

　　　　(2)比较第2和第3个数，将小数 放在前面，大数放在后面。

　　　　......

　　　　(3)如此继续，知道比较到最后的两个数，将小数放在前面，大数放在后面，重复步骤，直至全部排序完成

　　　　(4)在上面一趟比较完成后，最后一个数一定是数组中最大的一个数，所以在比较第二趟的时候，最后一个数是不参加比较的。因此有array.length-1-i这句代码，就是为了减小运算量

　　　　(5)在第二趟比较完成后，倒数第二个数也一定是数组中倒数第二大数，所以在第三趟的比较中，最后两个数是不参与比较的。

　　　　(6)依次类推，每一趟比较次数减少依次

稀疏数组

需求：编写五子棋游戏中，存盘退出和续上盘的功能
很明显，应该用二维数组来记录

分析：二维数组的很多数值都是默认值0，因此记录了很多没有意义的数据
解决：使用稀疏数组解决。