day23 Java基础——数组详解

day23 Java基础——数组(array)

1. 数组的概述

数组是一种特殊的数据结构，用于存储一系列相同类型的数据。在Java中，数组是一个对象，它可以存储基本数据类型（如int、float、double等）和对象引用（如String、自定义类等）。数组的大小在创建时确定，一旦创建，数组的大小就不能更改。
四个基本特点：

2. 数组的声明和创建

2.1 声明数组

声明数组时，需要指定数组的类型和名称。

int[] numbers; // 声明一个整型数组
String[] names; // 声明一个字符串数组
1
2

2.2 创建数组

创建数组时，需要指定数组的大小。

int[] numbers = new int[5]; // 创建一个包含5个整数的数组
String[] names = {"Alice", "Bob", "Charlie"}; // 创建一个包含3个字符串的数组
1
2

2.3 内存分析

数组的边界：

2.4 数组的三种初始化

在Java中，数组可以通过三种方式进行初始化：

1. 静态初始化：在声明数组的同时为数组元素赋值。
2. 动态初始化：创建数组对象后，再为数组元素赋值。
3. 数组初始化器：使用数组初始化器为数组元素赋值。

静态初始化

静态初始化是指在声明数组时直接为数组元素赋值。

int[] intArray = {1, 2, 3, 4, 5};
String[] stringArray = {"Apple", "Banana", "Cherry"};
1
2

动态初始化

动态初始化是指创建数组对象后，再为数组元素赋值。

int[] intArray = new int[5]; // 创建一个包含5个整数的数组
intArray[0] = 1;
intArray[1] = 2;
intArray[2] = 3;
intArray[3] = 4;
intArray[4] = 5;
1
2
3
4
5
6

数组的默认初始化

数组是引用类型，它的完素指当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

3. 数组的使用

3.1 访问数组元素

数组中的元素可以通过索引访问，索引从0开始。

int firstElement = numbers[0]; // 访问第一个元素
int lastElement = numbers[4]; // 访问最后一个元素
1
2

3.2 数组的遍历

可以使用循环结构（如for循环）来遍历数组中的所有元素。

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

3.3 数组的复制

可以使用System.arraycopy()方法来复制数组。

int[] newNumbers = new int[10];
System.arraycopy(numbers, 0, newNumbers, 0, numbers.length);
1
2

3.4 数组的排序

可以使用Arrays.sort()方法来对数组进行排序。

Arrays.sort(numbers);
1

3.5 数组的搜索

可以使用Arrays.binarySearch()方法来对排序后的数组进行二分搜索。

int index = Arrays.binarySearch(numbers, 3);
1

4. 多维数组

在Java中，多维数组（Multi-dimensional Array）是指一个数组的每个元素本身也是一个数组。多维数组可以看作是一个数组的数组，它用于表示具有多个维度或层次的数据结构。

4.1 声明多维数组

声明多维数组时，需要指定数组的类型和维数。

int[][] matrix; // 声明一个二维整型数组
String[][] table; // 声明一个二维字符串数组
1
2

4.2 创建多维数组

创建多维数组时，需要指定每个维度的大小。

int[][] matrix = new int[3][4]; // 创建一个3行4列的二维整型数组
String[][] table = new String[2][3]; // 创建一个2行3列的二维字符串数组
1
2

4.3 访问多维数组元素

访问多维数组中的元素时，需要指定所有维度的索引。

int value = matrix[0][1]; // 访问二维数组的第一行第二列的元素
String name = table[1][2]; // 访问二维字符串数组的第二行第三列的元素
1
2

4.4 多维数组的遍历

可以使用嵌套循环结构（如for循环）来遍历多维数组中的所有元素。

for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.print(matrix[i][j] + " ");
    }
    System.out.println();
}
1
2
3
4
5
6

4.5 多维数组的复制

可以使用System.arraycopy()方法来复制多维数组。

int[][] newMatrix = new int[5][5];
System.arraycopy(matrix, 0, newMatrix, 0, matrix.length);
1
2

4.6 多维数组的排序

可以使用Arrays.sort()方法来对多维数组进行排序。

Arrays.sort(matrix, (a, b) -> a[0] - b[0]);
1

4.7 注意事项

• 内存分配：多维数组创建时，Java虚拟机会为数组分配连续的内存空间。
• 维度顺序：在Java中，多维数组的索引是从0开始的，且通常按照行优先的顺序访问数组。
• 初始化：多维数组创建后，如果没有显式初始化，其元素会自动被赋予默认值。对于整型数组，默认值是0；对于字符串数组，默认值是null。
  多维数组是Java编程中常用的数据结构，它提供了一种高效的方式来存储和操作具有多个维度或层次的数据。正确使用多维数组可以提高程序的效率和可读性。

5. Arrays类

在Java中，Arrays类是一个实用工具类，它包含了一系列静态方法，用于操作数组。这些方法涵盖了数组的排序、搜索、填充、复制和比较等功能。Arrays类是java.util包的一部分，因此在使用它之前，你需要导入这个包。
以下是Arrays类中一些常用的方法：

5.1 排序

Arrays.sort() 方法用于对数组进行排序。

int[] numbers = {3, 1, 4, 1, 5, 9};
Arrays.sort(numbers);
1
2

5.2 二分搜索

Arrays.binarySearch() 方法用于对排序后的数组进行二分搜索。

int[] numbers = {1, 3, 5, 7, 9};
int index = Arrays.binarySearch(numbers, 7);
1
2

5.3 复制

System.arraycopy() 方法用于复制数组。Arrays类提供了便捷的方法来包装这个系统方法。

int[] source = {1, 2, 3, 4, 5};
int[] destination = new int[source.length];
Arrays.copyOf(source, destination.length);
1
2
3

5.4 填充

Arrays.fill() 方法用于用指定值填充数组。

int[] numbers = {1, 2, 3, 4, 5};
Arrays.fill(numbers, 0);
1
2

5.5 比较

Arrays.equals() 方法用于比较两个数组是否相等。

int[] array1 = {1, 2, 3};
int[] array2 = {1, 2, 3};
boolean areEqual = Arrays.equals(array1, array2);
1
2
3

5.6 转置

Arrays.stream() 方法用于将数组转换为流（Stream）。

int[] numbers = {1, 2, 3, 4, 5};
IntStream stream = Arrays.stream(numbers);
1
2

5.7 注意事项

• Arrays类中的方法都是静态的，因此可以直接通过类名调用，不需要创建类的实例。
• 大多数Arrays方法都支持泛型，这意味着它们可以用于任何类型的数组。
• 某些方法（如sort()和binarySearch()）需要数组已经排序才能正确工作。
  Arrays类是Java中一个非常有用的工具，它提供了方便的数组操作功能，可以提高代码的效率和可读性。

6. 稀疏数组

在Java中，稀疏数组（Sparse Array）是一种特殊的数组，它用于处理大量零值的情况。在稀疏数组中，只有非零元素被存储，而零值的位置则通过一个额外的数据结构来记录。这种结构可以减少内存的使用，提高处理大矩阵的效率。

6.1 稀疏数组的创建

稀疏数组通常用于处理二维数组，其中大部分元素都是零。创建稀疏数组的第一步是创建一个原始的二维数组，并计算其中非零元素的个数。

int[][] originalArray = {{0, 0, 0}, {0, 0, 4}, {0, 0, 0}};
1

接下来，创建一个稀疏数组，并记录非零元素的值、行数和列数。

int[][] sparseArray = new int[4][3];
sparseArray[0][0] = 1; // 稀疏数组的行数
sparseArray[0][1] = 3; // 稀疏数组的列数
sparseArray[1][0] = 2; // 非零元素的行数
sparseArray[1][1] = 2; // 非零元素的列数
sparseArray[1][2] = 4; // 非零元素的值
1
2
3
4
5
6

6.2 稀疏数组的转换

将原始数组转换为稀疏数组的过程通常称为“稀疏化”。稀疏化后，可以使用稀疏数组来快速访问非零元素，而无需考虑零值。

6.3 稀疏数组的访问

访问稀疏数组中的元素时，需要使用稀疏数组中的行数、列数和值数组。

int value = sparseArray[2][2]; // 访问稀疏数组中的值
1

6.4 注意事项

• 稀疏数组主要用于处理大量零值的情况，可以显著减少内存的使用。
• 稀疏数组的创建和访问都需要更多的代码，但可以显著提高处理大矩阵的效率。
• 在实际应用中，通常会先检查数组中是否有足够的零值，以决定是否使用稀疏数组。
  稀疏数组是Java编程中处理大矩阵或大型二维数组的有效工具，它通过减少内存使用和提高访问效率来优化性能。

实操

1. 数组反转后打印出来

package com.study.array;

public class Demo02 {
    public static void main(String[] args) {

        int[] nums = {11,12,13,14,15};
        new Demo02().print(reverse(nums));

    }

    //反转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        for (int i =0 ; i<arrays.length;i++){
            result[i] = arrays[arrays.length-i-1];
        }
        return result;
    }

    //打印数组
    public void print(int[] arrays){
        for (int i = 0; i<arrays.length; i++){
            System.out.print(arrays[i]+" ");
        }
    }


}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

15 14 13 12 11

2. 冒泡排序

package com.study.array;

import java.lang.reflect.Array;
import java.util.Arrays;

public class Demo07 {
    public static void main(String[] args) {
        //冒泡排序
        int[] nums = {10000,999,2,1,6,5,8,12,5,67,23,12,89,0,32,11,99,45,23,444,123,321,55};
        System.out.println(Arrays.toString(nums));
        System.out.println(Arrays.toString(sort(nums)));

    }

    public static int[] sort(int[] array){
        int f = 0;
        for (int i = 0; i <= array.length-2; i++) {  //外循环:判断我们这个要走多少次
            for (int j = 0; j < array.length-i-1; j++) {    //内循环，如果前一个数比后一个数大，则交换位置
                if (array[j]>array[j+1]){
                    int max = array[j];
                    array[j] = array[j+1];
                    array[j+1] = max;
                    f++;
                    System.out.println(Arrays.toString(array)+"------第"+f+"步");
                }
            }
        }
        return array;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

3. 稀疏数组应用（棋盘记录与还原）

package com.study.array;

public class Demo08 {
    public static void main(String[] args) {
        //1.创建一个二维数组 11*11  0：没有棋子， 1：黑棋    2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;   //y,x
        array1[2][3] = 2;   //y,x

        //打印原始数组
        System.out.println("打印原始数组array1：");
        new Demo08().print(array1);

        //转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for (int y = 0; y < 11; y++) {
            for (int x = 0; x < 11; x++) {
                if (array1[y][x]!=0){
                    sum++;
                }
            }
        }
        System.out.println("获取有效值的个数为："+sum);


        //2.创建一个稀疏数组的数组
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;  //记录行数
        array2[0][1] = 11;  //记录列数
        array2[0][2] = sum;  //记录有效值个数


        //遍历二维数组，将非零的值存放至稀疏数组
        int count = 0;
        for (int y = 0; y < array1.length; y++) {
            for (int x = 0; x < array1[y].length; x++) {
                if (array1[y][x]!=0){
                    count++;
                    array2[count][0] = y;
                    array2[count][1] = x;
                    array2[count][2] = array1[y][x];
                }
            }
        }

        //打印稀疏数组
        System.out.println("打印稀疏数组array2：");
        new Demo08().print(array2);


        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];

        //2.给其中的元素还原它的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }

        //3.打印读取后的数组array3
        System.out.println("读取后的数组array3：");
        new Demo08().print(array3);


    }

    
    //打印二维数组的方法
    public void print(int[][] array){

        for (int[] y : array) {
            for (int x : y) {
                System.out.print(x + "\t");
            }
            System.out.println();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

部分内容引用自
https://www.bilibili.com/video/BV12J41137hu/?p=59&share_source=copy_web&vd_source=7f3536a42709e7d479031f459d8753ab