day23 Java基础——数组(array)
文章目录
- day23 Java基础——数组(array)
- 1. 数组的概述
- 2. 数组的声明和创建
- 2.1 声明数组
- 2.2 创建数组
- 2.3 内存分析
- 2.4 数组的三种初始化
- 静态初始化
- 动态初始化
- 数组的默认初始化
- 3. 数组的使用
- 3.1 访问数组元素
- 3.2 数组的遍历
- 3.3 数组的复制
- 3.4 数组的排序
- 3.5 数组的搜索
- 4. 多维数组
- 4.1 声明多维数组
- 4.2 创建多维数组
- 4.3 访问多维数组元素
- 4.4 多维数组的遍历
- 4.5 多维数组的复制
- 4.6 多维数组的排序
- 4.7 注意事项
- 5. Arrays类
- 5.1 排序
- 5.2 二分搜索
- 5.3 复制
- 5.4 填充
- 5.5 比较
- 5.6 转置
- 5.7 注意事项
- 6. 稀疏数组
- 6.1 稀疏数组的创建
- 6.2 稀疏数组的转换
- 6.3 稀疏数组的访问
- 6.4 注意事项
- 实操
- 1. 数组反转后打印出来
- 2. 冒泡排序
- 3. 稀疏数组应用（棋盘记录与还原）
1. 数组的概述
数组是一种特殊的数据结构，用于存储一系列相同类型的数据。在Java中，数组是一个对象，它可以存储基本数据类型（如int、float、double等）和对象引用（如String、自定义类等）。数组的大小在创建时确定，一旦创建，数组的大小就不能更改。
四个基本特点：
2. 数组的声明和创建
2.1 声明数组
声明数组时，需要指定数组的类型和名称。
int[] numbers; // 声明一个整型数组
String[] names; // 声明一个字符串数组
2.2 创建数组
创建数组时，需要指定数组的大小。
int[] numbers = new int[5]; // 创建一个包含5个整数的数组
String[] names = {"Alice", "Bob", "Charlie"}; // 创建一个包含3个字符串的数组
2.3 内存分析
数组的边界：
2.4 数组的三种初始化
在Java中，数组可以通过三种方式进行初始化：
- 静态初始化：在声明数组的同时为数组元素赋值。
- 动态初始化：创建数组对象后，再为数组元素赋值。
- 数组初始化器：使用数组初始化器为数组元素赋值。
静态初始化
静态初始化是指在声明数组时直接为数组元素赋值。
int[] intArray = {1, 2, 3, 4, 5};
String[] stringArray = {"Apple", "Banana", "Cherry"};
动态初始化
动态初始化是指创建数组对象后，再为数组元素赋值。
int[] intArray = new int[5]; // 创建一个包含5个整数的数组
intArray[0] = 1;
intArray[1] = 2;
intArray[2] = 3;
intArray[3] = 4;
intArray[4] = 5;
数组的默认初始化
数组是引用类型，它的完素指当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
3. 数组的使用
3.1 访问数组元素
数组中的元素可以通过索引访问，索引从0开始。
int firstElement = numbers[0]; // 访问第一个元素
int lastElement = numbers[4]; // 访问最后一个元素
3.2 数组的遍历
可以使用循环结构（如for循环）来遍历数组中的所有元素。
for (int i = 0; i < numbers.length; i++) {
System.out.println(numbers[i]);
}
3.3 数组的复制
可以使用System.arraycopy()方法来复制数组。
int[] newNumbers = new int[10];
System.arraycopy(numbers, 0, newNumbers, 0, numbers.length);
3.4 数组的排序
可以使用Arrays.sort()方法来对数组进行排序。
Arrays.sort(numbers);
3.5 数组的搜索
可以使用Arrays.binarySearch()方法来对排序后的数组进行二分搜索。
int index = Arrays.binarySearch(numbers, 3);
4. 多维数组
在Java中，多维数组（Multi-dimensional Array）是指一个数组的每个元素本身也是一个数组。多维数组可以看作是一个数组的数组，它用于表示具有多个维度或层次的数据结构。
4.1 声明多维数组
声明多维数组时，需要指定数组的类型和维数。
int[][] matrix; // 声明一个二维整型数组
String[][] table; // 声明一个二维字符串数组
4.2 创建多维数组
创建多维数组时，需要指定每个维度的大小。
int[][] matrix = new int[3][4]; // 创建一个3行4列的二维整型数组
String[][] table = new String[2][3]; // 创建一个2行3列的二维字符串数组
4.3 访问多维数组元素
访问多维数组中的元素时，需要指定所有维度的索引。
int value = matrix[0][1]; // 访问二维数组的第一行第二列的元素
String name = table[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();
}
4.5 多维数组的复制
可以使用System.arraycopy()方法来复制多维数组。
int[][] newMatrix = new int[5][5];
System.arraycopy(matrix, 0, newMatrix, 0, matrix.length);
4.6 多维数组的排序
可以使用Arrays.sort()方法来对多维数组进行排序。
Arrays.sort(matrix, (a, b) -> a[0] - b[0]);
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);
5.2 二分搜索
Arrays.binarySearch() 方法用于对排序后的数组进行二分搜索。
int[] numbers = {1, 3, 5, 7, 9};
int index = Arrays.binarySearch(numbers, 7);
5.3 复制
System.arraycopy() 方法用于复制数组。Arrays类提供了便捷的方法来包装这个系统方法。
int[] source = {1, 2, 3, 4, 5};
int[] destination = new int[source.length];
Arrays.copyOf(source, destination.length);
5.4 填充
Arrays.fill() 方法用于用指定值填充数组。
int[] numbers = {1, 2, 3, 4, 5};
Arrays.fill(numbers, 0);
5.5 比较
Arrays.equals() 方法用于比较两个数组是否相等。
int[] array1 = {1, 2, 3};
int[] array2 = {1, 2, 3};
boolean areEqual = Arrays.equals(array1, array2);
5.6 转置
Arrays.stream() 方法用于将数组转换为流（Stream）。
int[] numbers = {1, 2, 3, 4, 5};
IntStream stream = Arrays.stream(numbers);
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}};
接下来，创建一个稀疏数组，并记录非零元素的值、行数和列数。
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; // 非零元素的值
6.2 稀疏数组的转换
将原始数组转换为稀疏数组的过程通常称为“稀疏化”。稀疏化后，可以使用稀疏数组来快速访问非零元素，而无需考虑零值。
6.3 稀疏数组的访问
访问稀疏数组中的元素时，需要使用稀疏数组中的行数、列数和值数组。
int value = sparseArray[2][2]; // 访问稀疏数组中的值
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]+" ");
}
}
}
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;
}
}
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();
}
}
}
部分内容引用自
https://www.bilibili.com/video/BV12J41137hu/?p=59&share_source=copy_web&vd_source=7f3536a42709e7d479031f459d8753ab
