Java —— 数组
1. 数组的定义
数组:数组是一种用于存储多个相同类型元素的数据结构(数组属于引用数据类型) ▶ 数组元素的默认值规则:整型:byte,short,int,long,char默认值都为0 浮点型:float,double默认值都为0.0 布尔型:boolean默认值为0false |
语法:
数据类型[] 数组名 = new 数据类型[数组大小]
示例:int[] arr = new int[5]
/*
* 数组
*/
// =============数组的定义=============
// 整形数组的默认值为0(以下默认存储了5个0)
int[] arrInt = new int[5];
// 浮点型数组(0.0)
double[] arrDouble = new double[5];
// 布尔型数组(默认值为false)
boolean[] arrBoolean = new boolean[5];
// 声明并创建一个3x3的二维整数数组
int[][] matrix = new int[3][3];
// 声明并创建一个2x3x4的三维双精度浮点数数组
double[][][] tensor = new double[2][3][4];
(1) 数组元素初始化
元素初始化
① int[] arr = new int[5]; 🢂 默认初始化为0,0,0
② int[] arr = {1,2,3,4}; 🢂 初始化为1,2,3
③ int[] arr = new int[]{1,2,3,4}; 🢂 声明的同时,初始化为1,2,3
④ int[] arr; 🢂 先定义,再初始化
arr = new int[]{1,2,3}; 🢂 初始化为1,2,3
// =============数组元素初始化=============
// 初始化整数数组
int[] arr = {1, 2, 3, 4, 5};
// 初始化字符串数组
String[] arrString = {"Alice", "Bob", "Charlie"};
// 先声明,再赋值
int[] arrNum;
arrNum = new int[]{1, 2, 3};
(2) 数组元素的访问
访问规则:通过下标/索引访问元素,下标从0开始,最大值为数组长度 - 1 |
// =============数组元素的访问=============
int[] numbers = {1, 2, 3, 4, 5};
// 访问单个元素
int firstNumber = numbers[0]; // 访问第一个元素,值为1
int thirdNumber = numbers[2]; // 访问第三个元素,值为3
// 修改元素
numbers[0] = 10; // 修改第一个元素的值为10
numbers[3] = 8; // 修改第四个元素的值为8
// 遍历元素
for (int i = 0; i < numbers.length; i++) {
System.out.println(numbers[i]); // 逐个打印数组中的元素
}
// 获取数组长度
System.out.println("数组长度:" + numbers.length);
// 数组的最后一个元素
System.out.println("数组最后一个元素:" + numbers[numbers.length - 1]);
2. 数组相关案例
package bases;
import java.util.*;
public class Demo05_Arr {
public static void main(String[] args) {
/*
* 数组
*/
// 案例展示
// 生成随机数组
int[] randomArr = randomArr(10, 20);
System.out.print("随机生成的数组:");
arrFormat(randomArr);
// 对随机生成的数组求和
System.out.println("和为:" + sumArrayElements(randomArr));
// 最大值和最小值
System.out.println("最大值:" + findMaxValue(randomArr) + " 最小值:" + findMinValue(randomArr));
// 数据逆序
int[] reverseArr = reverseArray(randomArr);
System.out.print("逆序:");
arrFormat(reverseArr);
// java提供的Arrays方法sort升序
Arrays.sort(randomArr);
System.out.print("升序:");
arrFormat(randomArr);
int[] rev = reverseArray(randomArr);
System.out.print("降序(将升序的结果逆序输出即可):");
arrFormat(rev);
}
// 案例一:数组元素求和
public static int sumArrayElements(int[] array) {
int sum = 0;
for (int num : array) {
sum += num;
}
return sum;
}
// 案例二:数组元素查找最大值和最小值
public static int findMaxValue(int[] array) {
int max = array[0];
for (int i = 1; i < array.length; i++) {
if (array[i] > max) {
max = array[i];
}
}
return max;
}
public static int findMinValue(int[] array) {
int min = array[0];
for (int i = 1; i < array.length; i++) {
if (array[i] < min) {
min = array[i];
}
}
return min;
}
// 案例三:数组逆序
public static int[] reverseArray(int[] array) {
int[] reversedArray = new int[array.length];
for (int i = 0; i < array.length; i++) {
reversedArray[i] = array[array.length - 1 - i];
}
return reversedArray;
}
// 案例四:生成随机数组
/**
*
* @param n 生成的数组元素的个数
* @param m 生成元素的最大值范围
* @return arr 新生成的数组
*/
public static int[] randomArr(int n, int m) {
Random random = new Random();
int element;
int[] arr = new int[n];
for (int i = 0; i < arr.length; i++) {
element = random.nextInt(m);
arr[i] = element;
}
return arr;
}
// 案例五:一维整型数组格式的打印
public static void arrFormat(int[] array) {
System.out.print("[");
for (int i = 0; i < array.length; i++) {
if (i == array.length - 1) {
System.out.print(array[i]);
} else {
System.out.print(array[i] + ", ");
}
}
System.out.println("]");
}
}
.
3. 数组的复制
数组的特性:数组的长度在创建后是不可改变的,数组元素的内存空间是连续的 System.arraycopy()数组的复制:使用java提供的System.arraycopy()进行数组的复制(根据数组的定义:被操作两个数组的数组类型(元素类型)必须相同) ▶ 意义:将一个数组中的元素复制到另一个数组中,避免了手动遍历和逐个赋值的麻烦 Array.copyOf()数组的扩容:创建一个新的数组,并将原始数组的元素复制到新数组中,常用于数组的“扩容”(创建一个不同于原数组的新数组) 与 System.arraycopy() 不同,Arrays.copyOf() 方法更加简洁,无需指定起始位置和复制的元素个数,只需要指定新数组的长度即可 |
System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
src:源数组,即要复制的数组
srcPos:源数组开始复制的起始位置(索引)
dest:目标数组,即要将元素复制到的数组
destPos:目标数组放置的起始位置(索引)
length:要复制的元素个数。
public static <T> T[] copyOf(T[] original, int newLength)
original:原始数组,即要复制的数组
newLength:新数组的长度
/*
* 数组的复制(System.arraycopy()操作的两个数组的元素数据类型必须相同)
*/
int[] arrCopy = {1, 2, 3, 4, 5, 6};
int[] arrOri = new int[6];
System.arraycopy(arrCopy, 1, arrOri, 0, 4);
System.out.print("数组的复制:");
arrFormat(arrCopy);
// 扩容:重新创建新数组,将被复制的数组的元素赋值过去,
int[] newArr = Arrays.copyOf(arrCopy, arrCopy.length + 5);
System.out.print("数组扩容:");
arrFormat(newArr);
System.arraycopy()和Arrays.copyOf()的区别:
返回类型
System.arraycopy() 方法没有返回值,它直接在目标数组中覆盖原始数组的内容
Arrays.copyOf() 方法会创建一个新的数组,并将原始数组的元素复制到新数组中,并返回新数组
参数要求
System.arraycopy() 方法需要手动指定源数组的起始位置、目标数组的起始位置和要复制的元素个数
Arrays.copyOf() 方法只需要指定原始数组和新数组的长度即可,它会自动复制原始数组的全部元素
使用场景
System.arraycopy() 方法更适合在现有数组上进行部分元素的复制或覆盖操作
Arrays.copyOf() 方法更适合创建一个新的数组,且要复制整个原始数组