数组的概述

Array——多个相同类型的数据按顺序（有序性）排列的集合。 使用一个名字命名，通过编号的方式对这些数据进行统一管理。 数组名、索引、元素、数组的长度> > 数组的分类： 按照维度：一维数组、二维数组、三维数组 按照元素的数据类型：基本数据类型元素数组、引用数据类型元素数组(对象数组)

  1. 数组本身是引用数据类型，而数组中的元素可以是任何数据类型；
  2. 创建数组对象会在内存中开辟一块连续的空间，而数组名中引用的是这块连续空间的首地址；
  3. 数组的长度一旦确定，就不能修改；
  4. 可直接通过下标或索引的方式快速调用指定位置的元素。

    一维数组的使用

    一维数组的声明和初始化

    1. 声明：type var[];（或type[] var;）
      不能在数组的声明过程中指定其长度。
    2. 初始化：
      • 静态初始化：数组的初始化伴随着数组元素的赋值；
      • 动态初始化：数组的初始化和数组元素的赋值异步进行。

        初始化结束，数组的长度也就确定了。

  1. class OneDimensionalArray1 {
  2.     public static void main(String[] args) {
  3.         int[] IDs;  // 声明一个名为 IDs 的基本数据类型(int)的数组
  4.         IDs = new int[]{1001, 1002, 1003, 1004};  // 将大括号中 int 型的元素用静态的方式初始化到数组 IDs 中
  6.         String[] names = new String[5];  // 声明一个名为 names 的引用数据类型(String)数组后，动态地将其初始化其长度为 5
  7.     }
  8. }

访问数组指定位置的元素

  1. names[0] = "张三";  // 索引从 0 开始
  2. names[1] = "李四";
  3. names[2] = "王五";
  4. names[3] = "辣鸡";
  5. names[4] = "航航";

获取一维数组长度

使用属性<array>.length获取数组的长度。

遍历一维数组

  1. for (int i = 0; i < names.length; i++) {
  2.     System.out.print(names[i]);
  3. }

增强for循环：

  1. for (String name : names) {
  2.     System.out.print(name);
  3. }

一维数组元素的默认初始化值

03_Java 数组 - 图1

  1. class OneDimensionalArray2 {
  2.     public static void main(String[] args) {
  3.         byte[] bytes = new byte[3];
  4.         short[] shots = new short[3];
  5.         int[] ints = new int[3];
  7.         long[] longs = new long[3];
  8.         float[] floats = new float[3];
  10.         boolean[] booleans = new boolean[3];
  11.         char[] chars = new char[3];
  13.         String[] strings = new String[3];
  15.         for (byte i : bytes) {
  16.             System.out.print("\t" + "i = " + i);
  17.         }
  18.         System.out.println();
  19.         for (short i : shots) {
  20.             System.out.print("\t" + "i = " + i);
  21.         }
  22.         System.out.println();
  23.         for (int i : ints) {
  24.             System.out.print("\t" + "i = " + i);
  25.         }
  26.         System.out.println();
  28.         for (long i : longs) {
  29.             System.out.print("\t" + "i = " + i);
  30.         }
  31.         System.out.println();
  32.         for (float i : floats) {
  33.             System.out.print("\t" + "i = " + i);
  34.         }
  35.         System.out.println();
  37.         for (boolean i : booleans) {
  38.             System.out.print("\t" + "i = " + i);
  39.         }
  40.         System.out.println();
  41.         for (char i : chars) {
  42.             System.out.print("\t" + "i = " + i);
  43.         }
  44.         System.out.println();
  45.         for (String i : strings) {
  46.             System.out.print("\t" + "i = " + i);
  47.         }
  48.         System.out.println();
  49.     }
  50. }

运行结果：

  1.     i = 0    i = 0    i = 0
  2.     i = 0    i = 0    i = 0
  3.     i = 0    i = 0    i = 0
  4.     i = 0    i = 0    i = 0
  5.     i = 0.0    i = 0.0    i = 0.0
  6.     i = false    i = false    i = false
  7.     i =      i =      i =  
  8.     i = null    i = null    i = null

一维数组内存解析

03_Java 数组 - 图2

  1. 方法区中包含“常量池”、“静态域”以及类加载的相关信息；
  2. 栈中主要存放“局部变量”；
  3. 堆中存放new出来的结构：对象、数组。

分析示例

分析下列代码在内存中分配并解析的过程：

  1. public static void main(String[] args) {
  2.     int[] arr1 = new int[]{1, 2, 3};
  3.     String[] arr2 = new String[4];
  4.     arr2[1] = "刘德华";
  5.     arr2[2] = "张学友";
  6.     arr2 = new String[3];
  7. }

对于方法 中的变量，都是局部变量 。 案例中，main方法中的变量arr1、arr2都是局部变量。 在堆中，用连续空间第一个元素的16进制地址值表示这个对象的地址。将这个地址与new出来的对象名关联后，可通过对象名指向这个连续空间。

垃圾回收：通过引用计数算法对未被指针所用的对象执行删除。

方法执行完毕后，局部变量将不处在作用域中——出栈、垃圾回收。

03_Java 数组 - 图3

练习1

升景坊单间短期出租 4 个月，550 元/月，空调、卫生间、厨房齐全。求租客一枚，喜欢安静。所以要求来租者最好是同行或者刚毕业的年轻人，爱干净、安静。电话号码如下：

  1. class contactInformationOfRental {
  2.     public static void main(String[] args) {
  3.         int[] arr = new int[]{8, 2, 1, 0, 3};
  4.         int[] index = new int[]{2, 0, 3, 2, 4, 0, 1, 3, 2, 3, 3};
  5.         StringBuilder tel = new StringBuilder();
  6.         for (int j : index) {
  7.             tel.append(arr[j]);
  8.         }
  9.         System.out.println("联系方式：" + tel);
  10.     }
  11. }

运行结果：

  1. 联系方式：18013820100

练习2

  1. class GetGradesForGrades {
  2.     public static void main(String[] args) {
  3.         System.out.print("请输入待录入的学生成绩数：");
  4.         Scanner scanner = new Scanner(System.in);
  5.         int amountOfStudents = scanner.nextInt(), topScore = -2147483648;
  6.         int[] scores = new int[amountOfStudents];
  7.         for (int i = 0; i < scores.length; i++) {
  8.             System.out.print("学生" + (i + 1) + "：");
  9.             int score = scanner.nextInt();
  10.             scores[i] = score;
  11.             if (score > topScore) {
  12.                 topScore = score;
  13.             }
  14.         }
  15.         System.out.println("\n这" + amountOfStudents + "个学生中，成绩的最高分是：" + topScore + "\n");
  16.         System.out.println("次序\t成绩\t等级");
  17.         int order = 0;
  18.         for (int score : scores) {
  19.             System.out.println((order++ + 1) + "\t" + score + "\t" +
  20.                     ((topScore - score <= 10) ? "A"
  21.                             : (topScore - score <= 20) ? "B"
  22.                             : (topScore - score <= 30) ? "C" : "D")
  23.             );
  24.         }
  26.     }
  27. }

运行结果：

  1. 请输入待录入的学生成绩数：5
  2. 学生1：56
  3. 学生2：74
  4. 学生3：89
  5. 学生4：41
  6. 学生5：89
  8. 这5个学生中，成绩的最高分是：89
  10. 次序    成绩    等级
  11. 1    56    D
  12. 2    74    B
  13. 3    89    A
  14. 4    41    D
  15. 5    89    A

多维数组的使用

以二维数组为常用。Java 中多维数组不必都是规则矩阵形式。 我们可以把二维数组理解成一维数组作为另一一维数组的元素的形式。

声明和初始化

  1. class DoubleDimensionalArray1 {
  2.     public static void main(String[] args) {
  3.         int[][] arr1 = {{1, 2, 3}, {4, 5}, {6, 7, 8}};  // 二维数组的声明和静态初始化（类型推断）
  4.         String[][] arr2 = new String[3][2];  // 二维数组的声明和动态初始化之一
  5.         String[][] arr3 = new String[3][];  // 二维数组的声明和动态初始化之二
  6.         System.out.println("arr1 = " + Arrays.deepToString(arr1));
  7.         System.out.println("arr2 = " + Arrays.deepToString(arr2));
  8.         System.out.println("arr3 = " + Arrays.deepToString(arr3));
  10.     }
  11. }

运行结果：

  1. arr1 = [[1, 2, 3], [4, 5], [6, 7, 8]]
  2. arr2 = [[null, null], [null, null], [null, null]]
  3. arr3 = [null, null, null]

数组的声明和静态初始化在同一逻辑行时，可省略new <type>——类型推断。

注意特殊写法情况：int[] x, y[]; x是一维数组，y是二维数组 可以通过这种方式初始化：int[] x = new int[0], y[] = new int[0][];

  • 一维数组：int[] x、int x[]；
  • 二维数组：int[][] y、int[] y[]、int y[][]。
    • 二维数组初始化方式一：
      • <type>[][] arrayName = new <type>[<index1>][<index2>]（适用于矩阵数据）
  • 二维数组初始化方式二：
    • <type>[][] arrayName = new <type>[<index1>][]（适用于不确定元素个数的情景）

根据索引访问元素

<array>[index1][index2]

获取数组长度

<array>.length

遍历二维数组

  1. class DoubleDimensionalArray2 {
  2.     public static void main(String[] args) {
  3.         char[][] arr2 = {{'a', 'b', 'c'}, {'d', 'e', 'f', 'g', 'h'}, {'k', 'l', 'm', 'n'}};
  4.         for (char[] i : arr2) {
  5.             for (char j : i) {
  6.                 System.out.print("j = " + j + "; ");
  7.             }
  8.             System.out.println();
  9.         }
  10.     }
  11. }

运行结果：

  1. j = a; j = b; j = c; 
  2. j = d; j = e; j = f; j = g; j = h; 
  3. j = k; j = l; j = m; j = n;

二维数组元素的默认初始化值

  1. class DoubleDimensionalArray3 {
  2.     public static void main(String[] args) {
  3.         int[] arry1 = new int[3];  // 一维数组的命名和动态初始化
  4.         System.out.println(arry1);  // 一维数组的首地址值（[I@e580929）
  6.         float[][] array2 = new float[4][3];  // 二维数组的命名和动态初始化
  7.         System.out.println(array2);  // 指向堆中二维数组的地址（[[F@1cd072a9）
  8.         System.out.println(array2[0]);  // 指向内一层（这里是内层）数组的首地址（[F@7c75222b）
  9.         System.out.println(array2[0][0]);  // 内层元素的值（0.0）
  11.         double[][] array3 = new double[4][];
  12.         System.out.println(array3[1]);  // 只初始化了外层数组，内层数组暂未初始化，但内层数组是引用数据类型（null）
  13. //        System.out.println(array3[1][0]);  // 报错：NullPointerException（空指针异常）
  14.     }
  15. }

运行结果：

  1. [I@e580929
  2. [[F@1cd072a9
  3. [F@7c75222b
  4. 0.0
  5. null

对于返回的内存地址，含义如下：

  1. [表示变量指向一维数组，[[表示变量指向二维数组；
  2. I、F等字母表示数组中的元素数据类型；
  3. @后连接16进制的地址值，由 JVM 通过哈希算法生成，屏蔽了计算机底层的真实地址。
    • 对于多维数组的初始化方式一，如<type>[][] arrayName = new <type>[<index1>][<index2>]：
    • 外层元素：向内一层数组的首地址（是二维数组时，指向内层的首地址）；
    • 内层元素：与一维数组的初始化情况一致。
  • 对于多维数组的初始化方式二，如<type>[][] arrayName = new <type>[<index1>][]：
    • 外层元素：null（数组本身作为引用数据类型，默认初始化值是null，并不存在地址指向未初始化的内层对象）；
    • 内层元素：未被初始化，不可及。此时访问则报错：NullPointerException(空指针异常)。

二维数组的内存解析

03_Java 数组 - 图4

数据结构：

  1. 数据间的结构关系：集合 -> 一对一 -> 一对多 -> 多对多
  2. 数据的存储结构：
    线性表（顺序表）：链表、栈（先进后出）、队列（先进先出）
    树形结构：二叉树
    图形结构

算法： 排序算法、搜索算法

数组基础练习

使用for循环嵌套，获取多维数组中所有元素的和

  1. class GetSumOfArray {
  2.     public static void main(String[] args) {
  3.         int[][] array = new int[][]{{3, 5, 8}, {12, 9}, {7, 0, 6, 4}};
  4.         int sum = 0;
  5.         for (int[] a : array) {
  6.             for (int i : a) {
  7.                 sum += i;
  8.             }
  9.         }
  10.         System.out.println("sum = " + sum);
  11.     }
  12. }

运行结果：

  1. sum = 54

杨辉三角

  1. class YangHuiTriangle {
  2.     public static void main(String[] args) {
  3.         int range = 10;  // 杨辉三角的目标行数
  4.         int[][] triangleTable = new int[range][];  // 创建杨辉三角，只声明“行”
  5.         for (int line = 0; line <= range - 1; line++) {  // 用行索引 line 遍历每一行
  6.             triangleTable[line] = new int[line + 1];  // 在每一行新建长为行索引的内层数组
  7.             triangleTable[line][0] = triangleTable[line][triangleTable[line].length - 1] = 1;  // 每行第一个和每行最后一个
  8.             for (int i = 1; i < triangleTable[line].length - 1; i++) {  // 从索引为 2 的行开始，对每行的 1～-2 个为止
  9.                 triangleTable[line][i] = triangleTable[line - 1][i] + triangleTable[line - 1][i - 1];
  10.             }
  11.         }
  12.         for (int[] i : triangleTable) {
  13.             for (int j : i) {
  14.                 System.out.print("\t" + j);
  15.             }
  16.             System.out.println();
  17.         }
  18.     }
  19. }

运行结果：

  1.     1
  2.     1    1
  3.     1    2    1
  4.     1    3    3    1
  5.     1    4    6    4    1
  6.     1    5    10    10    5    1
  7.     1    6    15    20    15    6    1
  8.     1    7    21    35    35    21    7    1
  9.     1    8    28    56    70    56    28    8    1
  10.     1    9    36    84    126    126    84    36    9    1

数组中的常见算法

数组元素的赋值(杨辉三角、回形数等)

杨辉三角

见上文👈

随机赋值并保证唯一性

创建一个长度为 6 的 int 型数组，要求数组元素的值在 1～30 之间。随机赋值并保证各元素的值各不相同。

方法一

  1. class RandomUniqueArray1 {
  2.     public static void main(String[] args) {
  3.         int[] randomUniqueArray = new int[6];  // 新建一个长度为 6 的数值型数组
  4.         for (int i = 0; i < randomUniqueArray.length; ) {  // 遍历数组的每一个索引位置
  5.             for (; ; ) {  // 循环产生随机数，满足唯一性则退出循环
  6.                 int getRandom = (int) (Math.random() * 30 + 1);  // 获取一个区间 [1, 30] 的随机整数
  7.                 boolean isTheSame = false;  // isTheSame 为 false 是赋值的条件
  8.                 for (int j = 0; j < i; j++) {
  9.                     if (getRandom == randomUniqueArray[j]) {
  10.                         isTheSame = true;
  11.                         break;  // 找到相同值，跳出
  12.                     }
  13.                 }
  14.                 if (!isTheSame) {  // 具有唯一性则：赋值、准备下一个、跳过用于产生随机数的循环
  15.                     randomUniqueArray[i] = getRandom;  // 赋值
  16.                     i++;  // 准备下一个
  17.                     break;  // 跳过产生随机数的循环
  18.                 }
  19.             }
  20.         }
  21.         for (int randomUniqueInt : randomUniqueArray) {
  22.             System.out.print("\t" + randomUniqueInt);
  23.         }
  24.     }
  25. }

方法二

  1. class RandomUniqueArray2 {
  2.     public static void main(String[] args) {
  3.         int[] arr = new int[6];
  4.         for (int i = 0; i < arr.length; i++) {
  5.             arr[i] = (int) (Math.random() * 30) + 1;  // [0,1) -> [0,30) -> [1,31)
  6.             for (int j = 0; j < i; j++) {
  7.                 if (arr[i] == arr[j]) {
  8.                     i--;
  9.                     break;
  10.                 }
  11.             }
  12.         }
  13.         for (int j : arr) {
  14.             System.out.println(j);
  15.         }
  16.     }
  17. }

回形数

求数值型数组中元素的最大值、最小值、平均数、总和等

数组的复制、反转、查找(线性查找、二分法查找)

数组元素的排序算法

Arrays 工具类的使用

数组使用中的常见异常