Java基础之数组篇

什么是数组？

数组是由一组具有相同数据类型的元素组成，这些元素按照一定的顺序排列。数组可以包含任何基本数据类型，如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]);
        }
    }
}