(JavaSE) 数组

1. 数组的作用

当我们要对打印几位学生其中一门科目的成绩时

public class Blogs {
    public static void main(String[] args) {
        int score1 = 60;
        int score2 = 69;
        int score3 = 79;
        int score4 = 83;
        int score5 = 99;
        System.out.println(score1);
        System.out.println(score2);
        System.out.println(score3);
        System.out.println(score4);
        System.out.println(score5);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

这样写是没问题的，但是当我们要打印全校的学生成绩呢，那就会很麻烦，
值得注意的是成绩的类型都是一样的，这时我们就可以使用数组进行打印。

2. 数组的创建及初始化

2.1 数组的创建

int[] array1 = new int[5];  //创建一个可以容纳5个 int 类型元素的数组
double[] array2 = new double[5]; //创建一个可以容纳5个double类型元素的数组
char[] array3 = new char[5]; //创建一个可以容纳5个char类型元素的数组
1
2
3

2.2 数组的初始化

初始化的三种方式

public class Blogs2 {
    public static void main(String[] args) {
        //第一种初始化方式
        int[] array1 = {1, 2, 3, 4, 5, 6, 10};
        //第二种初始化方式
        int[] array2 = new int[]{1, 2, 3, 4, 5, 6, 10};
        //第三种初始化方式
        int[] array3 = new int[7];
        System.out.println(array1.length); //同过 数组名.length 计算数组长度
    }
}
1
2
3
4
5
6
7
8
9
10
11

1. 第一、二种初始化方式为静态初始化，静态初始化即在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定，即在初始化时编译器会根据 {} 中元素个数确定数组长度，第二种中 T[] 的 [] 中不能输入具体的数字。
2. 第一种其实是和第二种是一样的，这样写就是省略了 new int[] 但是编译器在编译代码时会还原。
3. 第三种为动态初始化，动态初始化即在创建数组时，直接指定数组中元素的个数，T[] 的 [] 中必须指明数组长度，当我们没有对其进行赋值时，默认为类型对应的 0 值，如果数组中存储元素类型为引用类型，默认值为null。
4. 计算数组长度方法，数组名.length

注意：使用静态初始化分两行写时不可以省略 new T[]

int[] array1;
array1 = new int[]{1, 2, 3, 4,};
1
2

3. 数组的使用

3.1 数组中元素的访问

数组的下标是从 0 开始的，通过下标可以访问和修改元素，如下图：

public class Main {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        array[2] = 19; //下标为2的元素变为19
        System.out.println(array[2]); //打印下标为2的元素
    }
}
1
2
3
4
5
6
7

下标为 2 的元素被改变了，即元素 3 变为 19

3.2 遍历数组方法

所谓 “遍历” 是指将数组中的所有元素都访问一遍, 访问是指对数组中的元素进行某种操作

1. 使用 for 循环进行遍历。

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

2. 使用 for-each 进行遍历

public class Main{
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        for (int x : array) { //将 array 中元素值从0下标开始逐一赋值给x
            System.out.print(x + " ");
        }
    }
}
1
2
3
4
5
6
7
8

这个意思是每循环一次 array 就会把一个值赋给 x ，直到数组中元素都赋值一遍，需要注意的是冒号左边的类型需要和 array 数组类型一致。

3. 使用 Arrays 工具类的方法进行遍历

import java.util.Arrays;
public class Main{
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        String ret = Arrays.toString(array); //会返回一个字符串，需要接收
        System.out.println(ret);
    }
}
1
2
3
4
5
6
7
8

1. 传入数组会返回一个字符串的表达方式
2. 使用 Arrays.toString(); 时需要在开头写 import java.util.Arrays; 原因是使用库的工具类时需要说明。
3. 使用时会返回一个字符串，所以要用一个 String 引用类型进行接收

4. 数组是引用类型

4.1 JVM中的内存有那些

内存是一段连续的存储空间，主要用来存储程序运行时数据的。比如：

1. 程序运行时代码需要加载到内存
2. 程序运行产生的中间数据要存放在内存
3. 程序中的常量也要保存
4. 有些数据可能需要长时间存储，而有些数据当方法运行结束后就要被销毁
5. 如果对内存中存储的数据不加区分的随意存储，那对内存管理起来将会非常麻烦。

4.2 数组如何开辟空间

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

以下是 array 开辟空间过程：

我们试着打印 array 这个变量，它会是一个地址。

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

4.3 数组 null 的意思

int[] array = null; 代表这个引用 不指向任何对象
1

public class Main{
    public static void main(String[] args) {
        //int[] array = 0;   错误的，
        int[] array = null;   //代表 array 这个引用不指向任何对象
        System.out.println(array.length);	// 错误，array 不指向任何对象，没有长度
        System.out.println(array[0]);  // 错误，和上面一个道理
    }
}
1
2
3
4
5
6
7
8

让我们再来看看以下程序：

import java.util.Arrays;
public Main {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3, 4};
        int[] array2 = array1;
        System.out.println("array1=" + Arrays.toString(array1));
        System.out.println("array2=" + Arrays.toString(array2));
    }
}
1
2
3
4
5
6
7
8
9

int[] array2 = array1; 代表 array2这个引用 引用/指向了 array1 所引用/指向的对象，同时可以通过array2 来修改 array1，它们存着一样的地址，下面我们来画画图理解：

4.4 引用不能同时指向多个对象

我们来看看为什么

import java.util.Arrays;
public class Main{
    public static void main(String[] args) {
        int[] array = {1, 2, 4};
        array = new int[]{1, 3, 9};
        array = new int[]{2, 0, 3};
        System.out.println(Arrays.toString(array));
    }
}
1
2
3
4
5
6
7
8
9

可以猜猜这个数组最后打印了什么，下面我们来画画图，这里我们简略画一下就好

4.5 数组作为方法返回值

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

我们来画图理解：

5. 二维数组

5.1 二维数组的使用

public class Main {
    public static void main(String[] args) {
        int[][] array1 = {{1, 2, 3}, {3, 2, 1}};
        
        int[][] array2 = new int[][]{{1, 2, 3}, {3, 2, 1}};
        
        int[][] array3 = new int[2][3];
    }
}
1
2
3
4
5
6
7
8
9

5.2 遍历打印二维数组

1. 使用 for 循环打印

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

二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组。

所以代码可改成

    public static void main(String[] args) {
        int[][] array = {{1, 2, 3}, {3, 2, 1}};
        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();
        }
    }
1
2
3
4
5
6
7
8
9

2. 使用 for-each 进行遍历打印

    public static void main(String[] args) {
        int[][] array = {{1, 2, 3}, {3, 2, 1}};
     //因为二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组，所以我们用一维数组接收
        for (int[] array1 : array) {
            for (int x : array1) {
                System.out.print(x + " ");
            }
            System.out.println();
        }
    }
1
2
3
4
5
6
7
8
9
10

解释：因为二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组，所以我们用一维数组接收，一维数组接收后再经过每一次循环从 0 下标开始逐一将元素赋值给 x

3. 使用 Arrays.deepToString()

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

5.3 不规则数组

当我们这样写时，编译器不会报错

int[][] array = new int[2][];
1

它是长这样的

那我们再来看看

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[][] array = new int[2][];
        array[0] = new int[]{1, 2};
        array[1] = new int[]{1, 2, 3, 4};
        System.out.println(Arrays.deepToString(array));
    }
}
1
2
3
4
5
6
7
8
9

我们可以看到这就是不规则数组。

我们来画图看看

好的，到这里本章节就结束了，如发现有错误，请各位大佬及时指出。