什么是数组?
数组是由一组具有相同数据类型的元素组成,这些元素按照一定的顺序排列。数组可以包含任何基本数据类型,如byte、short、int、long、float、double、boolean、char、String等,也可以是对象。
元素 | |
数组元素 | 数组中的每一个数据 |
数组长度 | 数组中包含的元素的数量 |
数组元素下标 | 数组元素下标表示每个元素在数组中的位置。注意数组下标从0开始。同时意味着数组中最后一个元素的下标为 [ 数组长度 - 1] |
数组名 | 每个数组都有一个自己的名字它独一无二,是用来区分不同数组的标识。 |
数组元素
Java 中的数组具有以下特点:
- Java 中的数组要求所有的数组元素具有相同的数据类型。因此,一个数组里只能存储一种数据类型的数据,而不能存储多种数据类型的数据。
- 数组一旦初始化完成,那么这个数组的长度就不可改变。即使我们把数组中的元素全部清空,该数组的长度也不会改变。
- Java 数组中,既可以存储基本类型(例如 int、double、char 等)的数据,也可以存储引用类型(例如 String)的数据,只要所有的数组元素具有相同的类型即可。
- 数组也是一种数据类型,它本身是一种引用类型。例如 int 是一个基本类型,但 int[](这是定义数组的一种方式)就是一种引用类型了。
1. 数组的声明和创建(以一维数组为例):
声明数组:
dataType[] arrayName;或 dataType arrayName[];
创建数组:
arrayName = new dataType[arrayLength];
当然,我们可以将声明数组与初始化数组的过程合并:
dataType[] array = new dataType[length];
其中,dataType 是数组中元素的数据类型,array 是数组的名称,length 是数组的长度。
int[] arrayName = new int[5]; // 声明并创建一个包含5个整型元素的数组
2. 数组的初始化:
静态初始化:
dataType[] arrayName = {value1, value2, ...};
//声明并初始化一个数组 id 表示学生的编号
int[] id = {1001, 1002, 1010, 1011, 1022, 1023, 1024};
动态初始化:
dataType[] arrayName = new dataType[arrayLength];// 数组名 = new 数据类型[数组长度];
执行动态初始化时,程序员只需指定数组的长度,即为每个数组元素指定所需的内存空间,系统将负责为这些数组元素分配初始值。
分配初始值的规则如下:
- 数组元素的类型是基本类型中的整数类型(byte、short、int 和 long),则数组元素的值是 0。
- 数组元素的类型是基本类型中的浮点类型(float、double),则数组元素的值是 0.0。
- 数组元素的类型是基本类型中的字符类型(char),则数组元素的值是“\u0000”。
- 数组元素的类型是基本类型中的布尔类型(boolean),则数组元素的值是 false。
- 数组元素的类型是引用类型(类、接口和数组),则数组元素的值是 null。
注意:请不要同时使用静态初始化和动态初始化。即:不要在进行数组初始化时,既指定数组的长度,也为每个数组元素分配初始值。
3. 访问数组元素:
使用索引访问:
arrayName[index];
当我们通过下标获取数组中元素的值时,若下标值等于或大于数组的总长度,会拋出 ArraylndexOutOfBoundsException(数组越界)异常。
4. 数组的长度属性:
使用 length 属性获取数组长度:
arrayName.length
5. 多维数组:
声明和创建多维数组:
dataType[][] arrayName = new dataType[rowLength][colLength];
访问多维数组元素:
arrayName[rowIndex][colIndex];
6. 数组遍历:
使用 `for` 循环遍历数组:
for (int i = 0; i < arrayName.length; i++) {
// 代码
}
// 例如:
public static void main(String[] args) {
//声明并初始化一个数组
double[] price = new double[5];
//分别对数组的中各个元素进行赋值
price[0] = 99.9;
price[1] = 88.8;
price[2] = 77.7;
price[3] = 66.6;
price[4] = 55.5;
//通过 for 循环语句遍历数组的元素
for (int i = 0; i < price.length; i++) {
System.out.println("数组 price 中第" + (i + 1) + "个元素的值为:" + price[i]);
}
}
得到的结果:
数组 price 中第一个元素的值为:99.9
数组 price 中第一个元素的值为:88.8
数组 price 中第一个元素的值为:77.7
数组 price 中第一个元素的值为:66.6
数组 price 中第一个元素的值为:55.5
使用增强 for 循环遍历数组:
for (dataType element : arrayName) {
// 代码
}
// 示例
public static void main(String[] args) {
//声明并初始化一个数组
double[] price = new double[5];
//分别对数组的中各个元素进行赋值
price[0] = 99.9;
price[1] = 88.8;
price[2] = 77.7;
price[3] = 66.6;
price[4] = 55.5;
//通过 foreach 遍 历数组的元素
for (double a : price) {
System.out.println(a);
}
}
得到的结果:
99.9
88.8
77.7
66.6
55.5
7. 数组的排序:
使用 Arrays.sort(arrayName) 方法对数组进行排序。
使用 Arrays.sort(arrayName)
方法对数组进行排序时,需要确保数组元素的类型实现了 Comparable
接口,或者提供一个自定义的比较器(Comparator
)来指定排序规则。
8. 数组的复制:
1)使用 Arrays.copyOf(originalArray, newArrayLength) 方法复制数组。
import java.util.Arrays;
public class ArrayCopyExample {
public static void main(String[] args) {
int[] originalArray = {1, 2, 3, 4, 5};
// 使用 Arrays.copyOf() 方法复制数组
int[] newArray = Arrays.copyOf(originalArray, originalArray.length);
// 打印原始数组和复制后的新数组
System.out.println("Original Array: " + Arrays.toString(originalArray));
System.out.println("New Array: " + Arrays.toString(newArray));
}
}
上述代码中,我们创建了一个整数类型的原始数组 originalArray
,其中包含了一些元素。然后,我们使用 Arrays.copyOf(originalArray, originalArray.length)
方法,将原始数组复制到一个新的数组 newArray
中,同时指定新数组的长度为原始数组的长度。最后,通过打印原始数组和复制后的新数组来验证复制是否成功。
运行上述代码,输出结果为:
Original Array: [1, 2, 3, 4, 5]
New Array: [1, 2, 3, 4, 5]
通过调用 Arrays.copyOf()
方法,我们可以快速而方便地复制一个数组,并获得一个具有相同元素的新数组。
注意,Arrays.copyOf()
方法将自动填充默认值(例如,对于整数类型,将填充为0)以适应新数组的长度。
2)使用System.arraycopy()
复制数组
它可以在两个不同的数组之间进行元素的拷贝,并且可以实现对数组的部分拷贝。
public class ArrayCopyExample {
public static void main(String[] args) {
int[] sourceArray = {1, 2, 3, 4, 5};
int[] destinationArray = new int[5];
// 使用 System.arraycopy() 方法复制数组
System.arraycopy(sourceArray, 0, destinationArray, 0, sourceArray.length);
// 打印原始数组和复制后的新数组
System.out.println("Source Array: " + Arrays.toString(sourceArray));
System.out.println("Destination Array: " + Arrays.toString(destinationArray));
}
}
上述代码中,我们创建了一个整数类型的源数组 sourceArray
,其中包含了一些元素。然后,我们创建了一个相同长度的目标数组 destinationArray
,并使用 System.arraycopy()
方法将源数组的内容复制到目标数组中。在 System.arraycopy()
方法中,第一个参数是源数组,第二个参数是源数组的起始位置,第三个参数是目标数组,第四个参数是目标数组的起始位置,第五个参数是要拷贝的元素个数。
最后,通过打印源数组和复制后的目标数组来验证复制是否成功。
运行上述代码,输出结果为:
Source Array: [1, 2, 3, 4, 5]
Destination Array: [1, 2, 3, 4, 5]
通过调用 System.arraycopy()
方法,可以实现在不同数组之间快速而高效地复制元素。此方法还可以用于对数组的部分拷贝,即仅拷贝一部分元素。
9. 数组的扩容:
有了对数组复制部分的介绍结合两种方法可以引出数组扩容的方法:
import java.lang.reflect.Array;
import java.util.Arrays;
/**
* 数组扩容
*/
public class Example8 {
public static void main(String[] args) {
String[] personArr = {"A","B","C","D","E"};
//数组扩容: 第一个参数表示要扩容的数组 第二个参数表示,扩容后的新的数组的长度
//作用: 新建一个数组,并将原数组的所有元素全部拷贝至新数组中
//newArr = {"A","B","C","D","E", null}
String[] newArr = Arrays.copyOf(personArr, personArr.length + 1);
int index = 2;
// A B C D E null => A B C C D E
System.arraycopy(newArr, index, newArr, index+1, personArr.length - index);
//A B C C D E => A B F C D E
newArr[index] = "F";
personArr = newArr;
for(int i=0; i<personArr.length; i++){
System.out.println(personArr[i]);
}
}
}