java数组

数组释意

存储在一个连续的内存块中的相同数据类型（引用数据类型）的元素集合。

• 数组的长度是确定的，数组一旦创建，就不能改变大小了，这也是数组最大的缺陷，长度固定
• 数组元素的类型必须是相同类型，不能出现混合类型
• 数组本身是一个有序的集合操作，所以对于数组的内容操作往往会采用循环的模式完成，数组是一个有限的数据集合，所以应该使用 for 循环
• 数组的元素可以是任何数据类型，包括基本类型和引用类型
• 数组本身就是对象，因为数组是new出来的，java中对象是存在堆中的，因此数组无论保存原始类型还是其他对象类型，数组本身是存在堆中的
• 数组属于引用类型，所以在使用前一定要初始化开辟空间，数组中的每个元素相当于该对象的成员变量

数组的初始化

java中的数组必须先初始化才能使用。

        int [] a;                           // 声明数组 指定数组类型和变量名称
//      System.out.println(a);              // 编译器报错 因为只是声明并没有赋值
        int [] a1 = null;
        System.out.println(a1);                     // null
        System.out.println(Arrays.toString(a1));    // null
//      System.out.println(a1[0]);                  // java.lang.NullPointerException

        int [] b = new int[10];             // 声明并创建数组且定义数组大小 完成初始化 默认每个元素为0

初始化就是给数组元素分配内存，并为每个元素赋初始值。

初始化数组有两种方式：

静态初始化（事先知道数组里存储那些数据）

int [] c = new int[]{1,2,3,4,5,6};

动态初始化（事先不知道数组里存储那些数据，只知道数据的个数）

int [] b = new int[10]; 

 无论以哪种方式初始化数组，一旦初始化完成，数组的长度就固定了，不能改变，除非重新初始化。也就是说数组是定长的。

 数组创建的方法

        int [] a;                           // 声明数组 指定数组类型和变量名称
        int [] b = new int[10];             // 声明并创建数组且定义数组大小
        int [] c = new int[]{1,2,3,4,5,6};  // 声明并创建数组且指定数组元素 会自动分配数组大小
        int [] d = {1, 2, 3, 4, 5};         // 简洁写法 不用new 不用指定长度，只需要指定类型
        c = new int []{1,2,3};              // 重新分配新数组 无需创建新变量
        d = new int[10];                    // 重新分配新数组 无需创建新变量

数组的空间开辟示意图

看下面的代码：

public class ArrayDemo {
    public static void main(String args[]) {
        int data[] = null;
        data = new int[3]; //开辟一个长度为3的数组
        data[0] = 10;
        data[1] = 20;
        data[2] = 30;
    }
}

流程图：

数组的引用传递

那么既然说到了引用数据类型了，就一定可以发生引用传递，而现在的引用传递的本质也一定是：同一块堆内存空间可以被不同的栈内存所指向。

        int data[] = null;
        data = new int[3]; //开辟一个长度为3的数组
        int temp[] = null; //声明对象
        data[0] = 10;
        data[1] = 20;
        data[2] = 30;
        System.out.println(Arrays.toString(data)); // [10, 20, 30]
        temp = data;  //int temp[] = data;
        System.out.println(Arrays.toString(temp)); // [10, 20, 30]
        temp[0] = 99;
        System.out.println(Arrays.toString(data)); // [99, 20, 30]
        System.out.println(Arrays.toString(temp)); // [99, 20, 30]

 方法参数的引用传递，通过方法进行数组操作。

public class ArrayDemo {
    public static void main(String args[]) {
            int data[] = init();
            inc(data);
            printArray(data);
    }
    
    public static void inc(int arr[]) {
        for(int x = 0; x < arr.length; x++)
            arr[x] *= 2;
    }

    //此时的方法希望可以返回一个数组类型，所以返回值类型定义为整形数组
    public static int[] init() {
        return new int[] {1, 2, 3, 4, 6};
    }

    //定义一个专门进行数组输出的方法
    public static void printArray(int temp[]) {
        for (int i = 0; i < temp.length; i++) {
            System.out.print(temp[i] + "、");
        }        
    }
}

多维数组

多维数组可以看成是数组中的数组，例如二维数组就是一个特殊的一维数组，其每个元素都是一个一维数组。

        // 二维数组
        int [][] arry = new int[2][6];                  // 定义一个二维数组，每个数组有6个元素
        System.out.println(Arrays.toString(arry[0]));   // [0, 0, 0, 0, 0, 0]
        System.out.println(Arrays.toString(arry[1]));   // [0, 0, 0, 0, 0, 0]

        // 二维数组
        int [][] arry2 = new int[2][];
        arry2[0] = new int[]{1,2,3,4,5,6,7,8,9};
        arry2[1] = new int[]{1,2,3};
        System.out.println(Arrays.toString(arry2[0]));  // [1, 2, 3, 4, 5, 6, 7, 8, 9]
        System.out.println(Arrays.toString(arry2[1]));  // [1, 2, 3]

        // 二维数组 简洁定义
        int [][] arry3 = {
                {1,2,3,4,5},
                {6,7,8}
        };
        System.out.println(Arrays.toString(arry3[0]));  // [1, 2, 3, 4, 5]
        System.out.println(Arrays.toString(arry3[1]));  // [6, 7, 8]
        for (int i = 0; i ) {
            System.out.println(Arrays.toString(arry3[i]));
            for (int j = 0; j ) {
                System.out.println(arry3[i][j]);
            }
        }

        System.out.println("---------------------------------");

        // 三维数组
        int [][][] arry4 = {
                {{1,2},{2,3},{3,5}},
                {{6,7},{7,8}}
        };
        System.out.println(Arrays.toString(arry4[0][0])); // [1, 2]
        for (int i = 0; i ) {
            for (int j = 0; j ) {
                for (int k = 0; k ) {
                    System.out.println(arry4[i][j][k]);
                }
            }
        }

数组的常用方法

1. 数组打印

        // 数组打印
        int [] e = new int[]{1,2,3,4,5,6};
        System.out.println(e);                   // [I@1b6d3586
        System.out.println(Arrays.toString(e));  // [1, 2, 3, 4, 5, 6]

2. 设定数组默认值

        // 设定数组默认值
        int [] f = new int[10];
        Arrays.fill(f,6);                    // 设定数组所有元素的默认值
        System.out.println(Arrays.toString(f));  // [6, 6, 6, 6, 6, 6, 6, 6, 6, 6]

3. 数组排序 只要是基本数据类型的数组，Arrays.sort()都可以轻松地实现排序处理。

        // 数组排序
        int [] g = new int[]{11,2,3,41,5,16};
        Arrays.sort(g);
        System.out.println(Arrays.toString(g)); // [2, 3, 5, 11, 16, 41]

4. 数组拷贝

        // 数组拷贝
        int [] h = new int[]{1,2,3,8,5};
        int [] h2 = Arrays.copyOf(h,h.length);
        System.out.println(Arrays.toString(h2));  // [1, 2, 3, 8, 5]