当前位置:   article > 正文

day23 Java基础——数组详解

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

本文内容由网友自发贡献,转载请注明出处:https://www.wpsshop.cn/w/神奇cpp/article/detail/1012954
推荐阅读
相关标签
  

闽ICP备14008679号