数组的定义与使用（Java语言）

数组的基本用法

什么是数组?

数组：存储一组相同数据类型的数据的集合。比如：如果是整型类型的数组，只能放整型类型的数据，如果是双精度浮点类型的数组，就只能放双精度浮点类型的数组

数组的定义是什么?

数组定义跟C语言是不完全相同的，比如：整型数组——int[ ]，双精度浮点类型——double[ ]。
第一种定义方式：

public static void main(String[] args) {
        int[] array1 = {1, 2, 3, 4, 5, 6, 7};
        double[] array2 = {1, 2, 3, 4, 5, 6, 7};
    }

这是简单的数组定义的方式，我们发现明显与C语言定义数组是不同的，我们需要注意的是定义数组的时候不能在[ ]中加入具体的数字，比如：int[10] array。
第二种定义方式：

public static void main(String[] args) {
       int[] array=new int[3];
   }

new是一个关键字，作用是实例化一个对象，这种定义方式是比较少见的，作用是定义一个数组array，数组中有3个元素，但是没有进行初始化，因此数组中存放的默认都是0。
第三种定义方式：

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

这种定义方式同样比较少见，作用是定义一个数组并初始化，当然int[ ]同样不能写进任何数字。

数组的使用——获取长度&访问元素

获取长度：
数组的长度获取要比C语言中简单许多，我们在C语言中会用sizeof（）求数组的长度，但是Java中会很简单。

public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6};
        System.out.println(array.length);
    }

Java中求数组的长度只需要在数组后.length就能求出数组的长度，会非常的方便。
访问元素：
访问元素同样使用下标进行访问，下标从0开始依次往后。

public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6};
        System.out.println(array[3]);
    }

注意事项：

1. 使用 arr.length 能够获取到数组的长度，“.” 这个操作为成员访问操作符 后面在面向对象中会经常用到。
2. 使用 [ ] 按下标取数组元素. 需要注意, 下标从 0 开始计数。
3. 使用 [ ] 操作既能读取数据, 也能修改数据。
4. 下标访问操作不能超出有效范围 [0, length - 1] , 如果超出有效范围, 会出现下标越界异常。

遍历数组

遍历数组是数组经常使用的，因此遍历数组是必须掌握的。
for循环遍历：

public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6};
        for (int i = 0; i <array.length ; i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }

这种方式是我们经常使用的遍历数组的方式容易理解，当然还有更为简单的遍历方式。
for-each遍历

public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6};
        for (int x:array) {
            System.out.print(x+" ");
        }
        System.out.println();
    }

这两者最大的区别就在于，for循环能够获取下标，而for-each不能获取下标，因此在写代码过程中我们需要获得下表时，要使用for循环，相反可以采用for-each。
借助数组操作方法

public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6};
        String ret= Arrays.toString(array);
        System.out.println(ret);
    }

Arrays.toString：将参数的数组以字符串的形式进行输出。

数组作为方法的参数

我们先看一个用方法打印函数的例子：

public static void printf(int[]array){
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }

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

在理解这个函数中，我们需要理解array是什么？在Java中数组变量又叫做引用变量，是用来存储地址数组首元素的地址的。在这个例子中，操作系统在栈上创建array的引用变量，变量中存储“1”的地址，同时在堆上存储“1”，“2”，“3”，“4”，“5”，因此在方法中，我们将main方法中array中存储的地址传给printf方法中的array，所以printf方法中的array也是指向堆上存储的数字，这样就完成了打印。

参数传内置类型与参数传数组类型

我们看这样一个例子：

public static void main(String[] args) {
        int num = 0;
        func(num);
        System.out.println("num = " + num);
    }
public static void func(int x) {
        x = 10;
        System.out.println("x = " + x);
    }

我们可以看到修改形参 x 的值, 不影响实参的 num 值，这是因为num只是将num的值传给了x，但是x也是函数中的局部变量，跟num变量没有联系，出了函数后，x就会销毁，所以对x值的改变不能影响num的值。
我们再看数组类型传参例子：

public static void fun2(int[] array) {
        array[0] = 899;
    }

    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6};
        System.out.println(Arrays.toString(array));
        fun2(array);
        System.out.println(Arrays.toString(array));
    }

我们发现, 在函数内部修改数组内容, 函数外部也发生改变。此时数组名 arr 是一个 “引用” 。当传参的时候, 是按照引用传参，也就是此时array是存储的地址，将地址传给了fun2中的array。

空引用

null 在 Java 中表示 “空引用” , 也就是一个无效的引用。

public static void main(String[] args) {
        int[] arr = null;
        System.out.println(arr[0]);
    }

null 的作用类似于 C 语言中的 NULL (空指针), 都是表示一个无效的内存位置.。因此不能对这个内存进行任何读写操作。 一旦尝试读写, 就会抛出 NullPointerException。

数组作为方法的返回值

例子：写一个方法, 将数组中的每个元素都 * 2

   public static void func(int[] array) {
        for (int i = 0; i < array.length; i++) {
            array[i] = 2 * array[i];
        }
    }
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        func(array);
        System.out.println(Arrays.toString(array));
    }

这个方法应该是大部分同学能想到的，这个代码固然可行, 但是破坏了原有数组.。有时候我们不希望破坏原数组, 就需要在方法内部创建一个新的数组, 并由方法返回出来。

public static int[] func(int[] array) {
        int[] ret = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            ret[i] = 2 * array[i];
        }
        return ret;
    }

    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        System.out.println(Arrays.toString(func(array)));
    }

这样的话就不会破坏原有数组了,我们重新创建一个数组ret，并将最终的结果返回去，在打印。另外由于数组是引用类型, 返回的时候只是将这个数组的首地址返回给函数调用者, 没有拷贝数组内容, 从而比较高效。

二维数组

二维数组的定义跟一维数组的定义类似：

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

这是最为简单的定义方式，同样的[ ][ ]是一种类型，中间是不能添加任何的数字或者其他，如果定义为int[][] array={1,2,3,4,5,6,7};也是不行的，编译器无法知道几行几列。当然还有其他的定义方式：

public static void main(String[] args) {
        int[][] array2 = new int[][]{{1, 2, 3}, {4, 5, 6}};
    }

或者

public static void main(String[] args) {
        int[][]array=new int[2][3];
    }

这两种定义方式不是特别常用，但是我们需要了解，那么如何打印我们的二维数组呢？

public static void main(String[] args) {
        int[][] array = {{1, 2, 3}, {4, 5, 6}};
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[0].length; j++) {
                System.out.print(array[i][j]+" ");
            }
            System.out.println();
        }
    }

我们可以看到打印方式是和C及其相似的，不同之处就在于i和j的范围，这里就将二维数组是特殊的一维数组体现的淋漓尽致，我们在C中认识到二维数组就是有一维数组构成，以array[2][3]举例，array[2][3]其实是由两个一维数组组成，而这两个一维数组中分别为{1，2，3}和{4，5，6}，因此array.lenth就是array的长度，也就是2，而array[0].lenth就是array[0]中元素的个数，我们用图形来直观看看。

关于Java中数组的知识就是这么多了，如果有什么建议欢迎大家评论私信，谢谢大家！