Java SE知识点二：数组

前言：

Java中的数组在写法上于C语言有些许不同，但基本的遍历和引用还是相似的。

数组：可以看成是相同类型元素的一个集合。在内存中是一段连续的空间。

1. 数组的创建和初始化

1.1 数组的创建

在Java中，数组的创建是通过  类型[ ] + 数组名 = new 类型[ ] 来创建的

public static void main(String[] args){
        //数组
        int[] arr1 = {1,2,3,4,5};  //与C的不同之处
        int[] arr2 = new int[10];   //相当于初始化，10个0
        int[] arr3 = new int[] {1,2,3,4,5,6};

        //其他写法
        int[] arr4;
        arr4 = new int[10];
        int[] arr5;
        arr5 = new int[]{1,2,3,4,5,6};

        //其他类型
        double[] array2 = new double[]{1.0, 2.0, 3.0, 4.0, 5.0};
        String[] array3 = new String[]{"hell", "Java", "!!!"};
}

上述代码就是数组的创建

1.2 数组的初始化

数组的初始化可以分为 静态初始化 和 动态初始化。

静态初始化：

int[] array = new int[10]; //创建数组时，指定数组的元素个数

动态初始化：

int[] array2 = {1,2,3,4,5}; //在创建数组时不直接指定数据元素个数，而直接将指定具体的数据内容

2. 数组的访问与引用

2.1 数组的访问

因为数组在内存中是一段连续的空间，与C语言相同，空间编号都是从0开始的，然后递增，这称为数组下标。因此，可以通过数组下标对数组元素进行访问。

public static void main(String[] args){
        //打印
        int[]array = new int[]{10, 20, 30, 40, 50};
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);
        System.out.println(array[3]);
        System.out.println(array[4]);

        // 也可以通过[]对数组中的元素进行修改
        array[0] = 100;
        System.out.println(array[0]);

        //.length获取数组长度
        System.out.println(array.length);

        //遍历数组1
        for(int i = 0; i < array.length; i++){
            System.out.println(array[i]);
        }
        //遍历数组2  for each循环  区别是拿不到下标
        for (int x : array) {
            System.out.println(x);
        }
    }

上述代码给出了访问数组元素的方式，可以直接访问：array[下标]，也可以通过循环遍历访问。另外，for each 循环 与 for循环 的区别是，for循环是根据下标进行访问的，因此可以知道元素下标；而 for each 循环是通过数组元素赋值进行访问的，所以拿不到元素下标。

2.2 数组的引用

当我们直接打印数组的时候，并不是进行数组的访问。

public static void main1(String[] args){
        //数组
        int[] arr1 = {1,2,3,4,5};  //与C的不同之处
        
        System.out.println(arr1); //打印出来的不是元素，而是“地址” -- 堆；可以用于引用
}

可以看到，直接打印数组名，输出的是一串类似于地址的编码，对这个地址就可以进行数组的引用

比如：作为参数传入方法中，作为返回类型等等。

所以说数组是一种引用类型，引用数据类型创建的变量，一般称为对象的引用，其空间中存储的是对象所在空间的地址。引用变量并不直接存储对象本身，可以简单理解成存储的是对象在堆中空间的起始地址。这有点类似于C语言中的指针，也是储存地址的变量，只不过Java中的引用比指针更方便。

3. 数组的练习

3.1 数组拷贝

import java.util.Arrays; //必须引用Arrays

public static void main7(String[] args){
        int[] array = {1,2,3,4,5};

        //Arrays.copyOf()
        int[] copy = Arrays.copyOf(array,array.length); //如果length*2,相当于扩容
        //Arrays.toString() 将数组转换为字符串输出
        System.out.println(Arrays.toString(copy));

        int[] copy2 = Arrays.copyOfRange(array,2,5); //copy 任意范围 [2,5)
        System.out.println(Arrays.toString(copy2));

        //System.arraycopy
        int[] copy3 = new int[array.length];
        //              目标   目标起始   目的地 目的地起始  长度
        System.arraycopy(array,0,copy3,0,array.length);
        System.out.println(Arrays.toString(copy3));

    }

在C语言中关于数组的拷贝是用到 comcpy() 函数，而在Java中则用到 Array.valueOf()进行拷贝。

3.2 二分查找

不同于C语言中二分查找需要写一个函数来实现，Java中已经有现成的可以用。

public static void main(String[] args) {
        int[] array = {2,3,4,5,6,7,8};
                    //Arrays 中自带的函数 （数组，需要查找的元素）
        int index = Arrays.binarySearch(array,5);

        System.out.println(index);

    }

元素 5 的下标是 3

3.3 数组排序

C语言中我们经常写一个冒牌排序的函数对数组元素进行排序，在Java中也有内置的排序

public static void main(String[] args) {
    int[] arr = {9, 5, 2, 7};
    Arrays.sort(arr);
    System.out.println(Arrays.toString(arr));
}

通过Array.sort()，也可以快速对数组元素进行排序。

类似这样的还有很多，Java中都有比较方便的实现方法。

4. 二维数组

与C语言相同，二维数组也是许多一维数组的集合。

//二维数组
    public static void main(String[] args){
        //方式1
        int[][] arr = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
        //方式2
        int[][] arr2 = new int[][]{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
        //方式3
        int[][] arr3 = new int[3][4]; //初始化为0


        //循环遍历
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[0].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }

        //每行的长度也可以找
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]); //存的是地址，所以行都是一个数组
        System.out.println("-------------------");
        System.out.println(Arrays.toString(arr[0]));
        System.out.println(Arrays.toString(arr[1]));
        System.out.println(Arrays.toString(arr[2]));
        System.out.println("-------------------");
        System.out.println(arr[0].length);
        System.out.println(arr[1].length);
        System.out.println(arr[2].length); //这样找每行的长度
        System.out.println(arr.length); //行数


        //快速打印二维数组
        System.out.println(Arrays.deepToString(arr));

        //不规则的二维数组
        int[][] array = new int[2][];
        array[0] = new int[]{1,2,3};
        array[1] = new int[]{4,5,6,7,8};
        System.out.println(Arrays.deepToString(array));
    }

上述代码就是一些关于二维数组的内容，包括初始化，打印，长度，深度打印等等。

值的一题的是，关于二维数组的长度，我们使用 .length 的方法来获取，直接用数组名+.length 获得的是二维数组的行数，用 数组名[ i ] + .length 获取的是列数，也就是每行的长度。因此在 for 循环的时候，可以直接用上述方法获取长度。

小结：

数组这一部分的内容也是和C语言大同小异，也有自己的写法以及方便的用法，这也是Java容易上手的原因之一。接下来就是Java的主要内容，类和对象。