5. 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() 方法更适合创建一个新的数组，且要复制整个原始数组