文章目录

• 1. 数组的作用
• 2. 数组的创建及初始化
• • 2.1 数组的创建
  • 2.2 数组的初始化
• 3. 数组的使用
• • 3.1 数组中元素的访问
  • 3.2 遍历数组方法
• 4. 数组是引用类型
• • 4.1 JVM中的内存有那些
  • 4.2 数组如何开辟空间
  • 4.3 数组 null 的意思
  • 4.4 引用不能同时指向多个对象
  • 4.5 数组作为方法返回值
• 5. 二维数组
• • 5.1 二维数组的使用
  • 5.2 遍历打印二维数组
  • 5.3 不规则数组

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);}
}

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

2. 数组的创建及初始化

2.1 数组的创建

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

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

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

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

3. 数组的使用

3.1 数组中元素的访问

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

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

下标为 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] + " ");}}
}

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下标开始逐一赋值给xSystem.out.print(x + " ");}}
}

这个意思是每循环一次 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. 使用 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};}
}

以下是 array 开辟空间过程：

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

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

4.3 数组 null 的意思

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

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]);  // 错误，和上面一个道理}
}

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

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));}
}

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));}
}

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

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));}
}

我们来画图理解：

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];}
}

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();}}

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

所以代码可改成

    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();}}

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();}}

解释：因为二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组，所以我们用一维数组接收，一维数组接收后再经过每一次循环从 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));}
}

5.3 不规则数组

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

它是长这样的

那我们再来看看

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));}
}

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

我们来画图看看

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