数组定义及使用

---

一、数组基本用法

  在编写代码的过程中，有的时候会发现当需要的变量少的时候我们可以直接定义，例如需要两个整型变量：int a;int b就可以解决，但是当我们需要10个、20个甚至更多的变量的时候我们难道要一直这样定义变量吗？且不说这样的代码有多么的差，就是时间上也无法接受，因此Java中提供有数组。数组是一块连续的内存，存储的是一组相同类型的数据的集合。

1、数组的定义

使用格式：

  静态初始化（完整形式）：数组类型 [] 数组名称 = new 数据类型 [] { 初始化数据 };

  静态初始化（简写形式）：数据类型 [] 数组名称 = { 初始化数据 };

  动态初始化：数据类型 [] 数组名称 = new 数据类型 [ 数组长度 ];

使用上述格式创建数组：

//静态初始化数组（完整形式）
int[] array1 = new int[] {1, 5, 7, 9};
//静态初始化数组（简写形式）
int[] array2 = {2, 4, 6, 8};
//动态初始化数组
int[] array3 = new int[3];
array3[0] = 10;//通过数组索引给数组内容赋值
array3[1] = 20;
array3[2] = 30;
//也可以如下初始化定义
int[] array4 = null;
array4 = new int[] {};

注意事项：

  ① 数组的下标是从0开始，而不是从1开始，因此数组的最大索引值为：数组长度 - 1

  ② 动态初始化数组之后给数组赋值的时候索引值不能超过数组长度（即小于数组长度）。

  ③ 当数组定义为null的时候，此时并不能操作该数组，不然编译可以通过，但是运行时会引发空指针错误（java.lang.NullPointerException）。说明：空指针错误的产生原因有很多，但不一定是数组所引发的。

如下示例：

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

输出结果：

Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException: 0
at Test.main(Test.java:5)

  输出结果中括号里边表示：产生运行错误的代码行数。

2、数组的使用

  数组的使用以示例的代码为例使用数组。

示例一：获取数组长度和访问数组元素

public class Test {
    public static void main(String[] args) {
        int[] array = {2, 4, 6, 8};
        System.out.println("数组长度：" + array.length);
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);
        array[1] = 10;
        System.out.println("修改后数组第二个元素的值：" + array[1]);
    }
}

说明：array.length可以获取数组的长度，而不是数组索引最大值。

输出结果：

数组长度：4
2
4
6
修改后数组第二个元素的值：10

注意事项：

  ① 使用 [ ] 操作既可以读取数据，也可以修改数据。

  ② 下标（索引）访问操作不能超出有效范围[0, length - 1]，如果超出这个有效范围，运行时会出现下标越界异常（java.lang.ArrayIndexOutOfBoundsException）。如下使用则会引发该错误：

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

输出结果：

Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException: 5
at Test.main(Test.java:4)

示例二：遍历输出数组元素的三种形式

public class Test {
    public static void main(String[] args) {
        int[] array = {1, 3, 5, 7};
        //第一种遍历输出
        for(int i = 0;i<array.length;i++){
            System.out.print(array[i] + " ");
        }
        System.out.println();//遍历结束后换行
        //第二种形式
        for(int temp:array){
            System.out.print(temp + " ");
        }
        System.out.println();//遍历结束后换行
        //第三种形式
        System.out.println(Arrays.toString(array));
    }
}

输出结果：

1 3 5 7
1 3 5 7
[1, 3, 5, 7]

说明：

  ① 只有第一种遍历使用 [ ] 操作输出，因此只有该遍历可以修改数组元素和访问元素，其他两种方式都不能修改数组元素。

  ② 第二种形式使用for-each遍历数组，for-each也被称为增强for循环。

  ③ 第三种输出方式是使用了Arrays类中的方法，将数组元素输出。但是该方式的基本实现也是基于for循环实现的。

二、数组作为方法的参数

1、基本用法

示例：遍历输出数组元素

public class Test_4 {
    public static void main(String[] args) {
        int[] array = {10, 20, 30, 40};
        print(array);
    }
    public static void print(int[] array){//该方法的形参为整型数组
        for(int i = 0;i<array.length;i++){
            System.out.print(array[i] + " ");
        }
    }
}

输出结果：

10 20 30 40

2、理解引用类型

  首先观察两段代码：

① 方法的参数为基本类型

public class Test {
    public static void main(String[] args) {
        int a = 5;
        fun(a);
        System.out.println("a = " + a);
    }
    public static void fun(int x){
        x = 10;
        System.out.println("x = " + x);
    }
}

输出结果：

x = 10
a = 5

  解析：上述代码局部变量之间相互不影响，修改形参x的值，并不会应影响实参a的值。

② 方法的参数为引用类型（以数组为例）

public class Test {
    public static void main(String[] args) {
        int[] a = {1, 2, 3};
        fun(a);
        System.out.println("a[0] = " + a[0]);
    }
    public static void fun(int[] b){
        b[0] = 25;
        System.out.println("b[0] = " + b[0]);
    }
}

输出结果：

b[0] = 25
a[0] = 25

  解析：通过上述代码可以发现与①不同的结果，即在方法内部修改了数组元素，方法外部也修改了数组元素。此时a是一个“引用”，fun()方法中的参数属于引用传递。

  引用是类似于C语言中的指针，代码中的数组名a存储的是一个地址，使用的时候通过该地址的指向使用数据。上述②代码中创建新的数组后将数组的地址赋给变量a，传递至方法的只是a存储的地址，所以此时方法中的形参b和实参a指向的是同一个数组。因此方法中修改数组元素，则方法外部的数组元素也被修改。如下图：

  红色的横线表示原来的数组内容，新的红色的25表示经过方法调用之后修改了数组的内容。

说明：栈内存存储方式为先进后出，方法调用完毕之后释放资源。

总结：所谓的“引用”本质上只是存了一个地址。Java中将数组设定为引用类型，这样的话后续进行数组参数传参，其实只是将数组的地址传入到函数形参中。这样做的好处是可以避免数组的拷贝（数组可能长度较长，那么拷贝开销就会很大）。

3、数组作为方法的返回值

示例：动态初始化数组，数组未添加内容前的元素为基本数据类型的默认值。如整型数组中的元素默认值为0。

public class Test {
    public static void main(String[] args) {
        int[] arr = new int[5];
        int[] arrAddData = addData(arr);//返回值为整型数组类型，接收时也需要整型数组接收
        System.out.println(Arrays.toString(arrAddData));
    }
    public static int[] addData(int[] array){//往数组中添加元素
        for(int i = 0;i<array.length;i++){
            array[i] = i + 1;
        }
        return array;
    }
}

输出结果：

[1, 2, 3, 4, 5]

4、数组拷贝

  数组拷贝有四种方式：

    ① for循环

    ② Arrays.copyOf(数组名称，数组长度);

    ③ System.arraycopy(源数组，源数组起始位置，目标数组，目标数组起始位置，拷贝长度);

    ④ 数组名.clone()

示例：使用四种数组拷贝

public class Test_7 {
    public static void main(String[] args) {
        int[] array = {1, 3, 4, 6, 2, 8, 9};
        //第一种方法
        int[] one = new int[array.length];
        for(int i = 0;i<array.length;i++){
            one[i] = array[i];
        }
        System.out.println("第一种方法：" + Arrays.toString(one));
        //第二种方法
        int[] two = Arrays.copyOf(array,array.length);
        System.out.println("第二种方法：" + Arrays.toString(two));
        //第三种方法
        int[] three = new int[10];
        System.arraycopy(array,0,three,0,7);
        System.out.println("第三种方法：" + Arrays.toString(three));
        //第四种方法
        int[] four = array.clone();
        System.out.println("第四种方法：" + Arrays.toString(four));
    }
}

输出结果：

第一种方法：[1, 3, 4, 6, 2, 8, 9]
第二种方法：[1, 3, 4, 6, 2, 8, 9]
第三种方法：[1, 3, 4, 6, 2, 8, 9, 0, 0, 0]
第四种方法：[1, 3, 4, 6, 2, 8, 9]

注意：第三种方法是可以自由选择需要复制的数组内容。第二种和第四种这两种方式是由返回值的，因此使用的时候需要接收，且第四种方法属于Object类的方法。

三、二维数组

  二维数组的本质是一维数组，只不过每个元素又是一个一维数组。在Java中的二维数组与C语言中的存储不是相同的。

使用格式：

数据类型[][] 数组名称 = new 数据类型[行数][列数];

如图表示三行三列的二维数组。

示例：二维数组的定义及使用

public class Test {
    public static void main(String[] args) {
        int[][] array = new int[3][3];
        array[0][0] = 4;
        array[1][1] = 4;
        array[2][2] = 8;
        for(int i = 0;i<array.length;i++){//遍历每一行的元素
            for(int j = 0;j<array[i].length;j++){//遍历每一列的元素
                System.out.print(array[i][j] + " ");//遍历每一个元素
            }
            System.out.println();//换行
        }
    }
}

输出结果：

4 0 0
0 4 0
0 0 8

说明：二维数组也可以使用Arrays.deepToString(数组名);来遍历输出二维数组。