06 - 数组

累了就停下脚步，好好看看远处的青山绿水。

1. 为什么需要数组

一个养鸡场有6只鸡，它们的体重分别是3kg，4kg，1kg，2kg，6kg，3kg。

没有数组，就需要定义六个变量，一个变量代表一只鸡的体重。

使用数组，就可以定义一个数组，统一存放六只鸡的体重。

2. 数组介绍

• 数组用于存储固定大小的同类型数据元素的数据结构，是引用类型。
• 数组中的每个元素都可以通过其索引（一个整数）来访问。索引从0开始，因此对于任何数组，其第一个元素的索引都是0，第二个元素的索引是1，依此类推。
• 数组下标必须在指定范围内使用，否则报：下标越界异常。

3. 数组的使用

3.1 声明和初始化

// 声明一个整型数组
int[] arr1;
// 初始化一个包含5个整型元素的数组
arr1 = new int[5];  

// 声明并初始化一个包含10个整型元素的数组
int[] arr2 = new int[10];  

// 声明并初始化一个包含5个整型元素的数组
int[] arr3 = {1, 2, 3, 4, 5};  

数组创建后，如果没有赋值，有默认值

int 0，short 0，byte 0，long 0，float 0.0，double 0.0，char \u0000，boolean false，String null 

3.2 访问数组元素

int element = arr3[2];  // 访问arr3数组的第三个元素，其值为3

3.3 遍历数组

for (int i = 0; i < arr3.length; i++) {
    System.out.println(arr3[i]);
}

3.4 多维数组

Java还支持多维数组，如二维数组。二维数组可以看作是一个表格或矩阵。

int[][] matrix = new int[3][4];  // 声明并初始化一个3x4的二维数组
matrix[1][2] = 5;  // 设置第二行第三列的元素为5

3.5 数组方法

Java提供了一些用于操作数组的方法，如Arrays.sort()（用于对数组进行排序）。

import java.util.Arrays;

int[] arr = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
Arrays.sort(arr);  // 对arr数组进行排序
System.out.println(Arrays.toString(arr));  // 输出：[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

3.6 数组赋值机制

介绍

1. 基本数据类型赋值，这个值就是具体的数据，互相之间不影响。
2. 数组在默认情况下是引用传递，赋的值是地址。

// 基本类型
int n1 = 10; 
int n2 = n1;
n2 = 30;

// 数组
int[] arr1 = {1,2,3};
int[] arr2 = arr1;
arr2[0] = 10;

3.7 数组拷贝 

将 int[] arr1 = {10,20,30}，拷贝到 arr2 数组。

代码示例

public static void main(String[] args) {
    // 定义arr1
    int[] arr1 = {10,20,30};
    // 创建一个新的数组 arr2,开辟新的数据空间
    // 为了不浪费空间，大小为 arr1.length;
    int[] arr2 = new int[arr1.length];

    // 遍历 arr1 ，把每个元素拷贝到 arr2 对应的元素位置
    for(int i = 0; i < arr1.length; i++) {
        arr2[i] = arr1[i];
    }

    // 修改 arr2， 不会对 arr1 有影响. 
    arr2[0] = 100;

    // 输出 arr1
    System.out.println("====arr1 的元素====");
    for(int i = 0; i < arr1.length; i++) {
        System.out.println(arr1[i]);
    }
    // 输出 arr2
    System.out.println("====arr2 的元素====");
    for(int i = 0; i < arr2.length; i++) {
        System.out.println(arr2[i]);
    }
}

3.8 数组反转

把数组的元素内容反转

arr {11,22,33,44,55,66} {66, 55,44,33,22,11}

方式一：创建一个新数组，然后将原数组的内容逆序输出到新数组当中

public static void main(String[] args) {
    // 定义数组
    int[] arr = {11, 22, 33, 44, 55, 66};

    // 1. 先创建一个新的数组 arr2 ,大小 arr.length
    // 2. 逆序遍历 arr ,将 每个元素拷贝到 arr2 的元素中(顺序拷贝)
    int[] arr2 = new int[arr.length];
    // 逆序遍历 arr
    for(int i = arr.length - 1, j = 0; i >= 0; i--, j++) {
        arr2[j] = arr[i];
    }
    // 让 arr 指向 arr2 数据空间, 此时 arr 原来的数据空间就没有变量引用，会被当做垃圾，销毁
    arr = arr2;

    // 输出 arr
    System.out.println("====arr 的元素情况=====");
    for(int i = 0; i < arr.length; i++) {
        System.out.print(arr[i] + "\t");
    }
}

但是，这种方式在数据量多的时候，创建新数组浪费空间。

方式二：数组内部对称交换

public static void main(String[] args) {
    // 定义数组
    int[] arr = {11, 22, 33, 44, 55, 66};

    // 1. 把 arr[0] 和 arr[5] 进行交换 {66,22,33,44,55,11}
    // 2. 把 arr[1] 和 arr[4] 进行交换 {66,55,33,44,22,11}
    // 3. 把 arr[2] 和 arr[3] 进行交换 {66,55,44,33,22,11}
    // 每次交换时，对应的下标 是 arr[i] 和 arr[arr.length - 1 -i]
    int temp = 0;
    int len = arr.length;
    for( int i = 0; i < len / 2; i++) {
        temp = arr[len - 1 - i];
        arr[len - 1 - i] = arr[i];
        arr[i] = temp;
    }

    System.out.println("===翻转后数组===");
    for(int i = 0; i < arr.length; i++) {
        System.out.print(arr[i] + "\t");
    }
}