1. 数组的定义

数组的定义一共有 4 种方式，具体如下：

// 第1种: 定义数组变量，然后初始化
int[] nums;
nums = new int[3];
// 第2种: 直接定义并初始化
int[] nums = new int[3];
// 第3种: 直接定义和初始化，并赋值
int[] nums = {1, 2, 3};
// 第4种: 直接定义和初始化，并赋值
int[] nums = new int[]{1, 2, 3};

💡所有已经初始化但并未进行赋值的数组，其元素会有默认值，如果是int数组，默认值为 0。

2. 元素的赋值/引用

数组的下标是从 0 开始的，下面示例对数组的元素进行赋值：

int[] nums = new int[3];
nums[0] = 1;
nums[1] = 2;
nums[2] = 3;

💡如果只是定义了数组，但并未对其初始化，它是不可以被赋值的。

数组元素的引用也非常简单：

System.out.println(nums[1]);

💡数组的赋值和引用均不能越界

3. 数组的属性

所有初始化后的数组都会具备一个length属性，表示数组的长度。

int[] nums = new int[3];
System.out.println(nums.length);  // 3

4. 数组的性质

数组具备以下特性：

一旦创建，长度不可以改变
每个位置只能存储一个值
数组创建后会有默认值，分别为：
- 对于int、byte、short、long类型的数组，默认值为 0
- 对于float、double类型的数组，默认值为 0.0
- 对于char类型的数组，默认值为\u0000
- 对于boolean类型的数组，默认值为false
- 对于String类型的数组，默认值为null
索引下标从 0 开始，不可以越界
初始化后的数组具备length属性
数组中元素可以是基本类型，也可以是引用类型
5. 数组的遍历
数组的遍历一共有 2 种方式，第一种方式为循环（for或while）+数组元素的引用，第二种则是之前介绍过的foreach方式。 ```java int[] nums = {1, 2, 3, 4, 5};

// for 循环方式 for (int i = 0; i < num.length; i++) { System.out.println(nums[i]); }

// while 循环方式 int j = 0; while (j < nums.length) { System.out.println(nums[j]); }


`foreach`方式更为简单，直接上示例：
```java
int[] nums = {1, 2, 3, 4, 5};
for (int num: nums) {
    System.out.println(num);
}

学会了数组的遍历，结合之前所需的控制语句，我们就可以进行数组元素的查找、输出最大最小值、数组元素的位移、数组的扩容以及数组的反转等。

5.1 查找指定元素

通过遍历+**if**条件判断的组合，非常容易地可以获知指定元素是否存在于数组中。

public class LookupArrayElement {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5};
        int target = 3;
        for (int num: nums) {
            if (num == target) {
                System.out.println("You found the element!");
                break;
            }
        }
    }
}

5.2 查找最大值/最小值

查找数组中最大/最小值，寻找最大值的过程可以解释为，先将最大值maxValue设定为数组中第一个元素，随后通过遍历数组元素的方式，如果所访问的元素比当前maxValue更大，则更新maxValue为该元素值。同理，最小值也是这样寻找。

public class MaxArrayElement {
    public static void main(String[] args) {
        int[] nums = {2, 1, 2, 3, 4, 5};
        int maxValue = nums[0];
        int minValue = nums[0];
        for (int num: nums) {
            if (num > maxValue) {
                maxValue = num;
            } else if (num < minValue) {
                minValue = num;
            }
        }
        System.out.println("Max Value is " + maxValue);
        System.out.println("Min Value is " + minValue);
    }
}

5.3 数组元素的位移

实现数组元素的交换，这个操作在很多语言中非常容易，比如 Python 中交换列表中两个元素的位置：

lst = [1, 2, 3]
lst[0], lst[1] = lst[1], lst[0]

但是 Java 中实现这样的逻辑，我们需要借助中间变量临时存储：

int[] nums = {1, 2, 3, 4, 5};
int temp = nums[0];
nums[0] = nums[1];
nums[1] = temp;

5.4 数组的扩容

之前我们提到过，数组一旦创建后，其长度是不可以改变的，受到上面数组元素位移的启发，我们也可以实现数组的扩容：

int[] nums = {1, 2, 3, 4, 5};
int[] temp = new int[nums.length * 2];
nums = temp;
System.out.println(nums.length);  // 10

5.5 数组的反转

数组的反转即得到一个顺序完全相反的数组，实现方式一般有 2 种。第一种是创建一个等长的新数组，将原先数组元组倒序引用：

int[] nums = {1, 2, 3, 4, 5};
int[] newNums = new int[nums.length];
for (int i = 0; i < nums.length; i++) {
    newNums[i] = nums[nums.length - 1 - i]
}

第二种方式则是采用数组元素交换的方式，先交换第一个元素和最后一个元素的位置，接着交换第二个元素和倒数第二个元素的位置，依次类推。

int[] nums = {1, 2, 3, 4, 5};
for (int i = 0; i < nums.length / 2; i++) {
    int temp = nums[i];
    nums[i] = nums[nums.length - 1 -i];
    nums[nums.length - 1 -i] = temp;
}

Java

🔰数组