核心概念

要理解 Java 数组的两个基本操作：

1. 声明数组: 告诉编译器你想要一个 String 类型的数组，此时数组还未被创建，也没有分配内存。

   String[] names; // 推荐方式
   // 或者
   String names[]; // 也可以，但不推荐，容易混淆

2. 创建/初始化数组: 使用 new 关键字为数组分配内存空间，并指定其长度，数组中的每个元素都会被赋予一个默认值（对于 String 类型，默认值是 null）。

   names = new String[3]; // 创建一个可以存放3个String的数组
   // names 的内容是: [null, null, null]

赋值就是给已经创建好的数组中的各个元素存入具体的 String 值。

声明、创建、然后逐个赋值

这是最基础、最直观的方法,适合初学者理解整个过程。

步骤：

1. 声明数组。
2. 使用 new 创建数组并指定长度。
3. 通过索引（从 0 开始）为数组的每个元素赋值。

代码示例：

public class StringArrayExample {
    public static void main(String[] args) {
        // 1. 声明一个 String 数组
        String[] fruits;
        // 2. 创建数组，指定长度为 3
        fruits = new String[3];
        // 3. 通过索引为每个元素赋值
        fruits[0] = "Apple";
        fruits[1] = "Banana";
        fruits[2] = "Cherry";
        // 打印数组内容
        System.out.println(fruits[0]); // 输出: Apple
        System.out.println(fruits[1]); // 输出: Banana
        System.out.println(fruits[2]); // 输出: Cherry
    }
}

声明、创建并初始化（一步完成）

这是最常用、最简洁的初始化方式,可以在声明数组的同时就为其赋值。

语法：

String[] arrayName = { value1, value2, value3, ... };

代码示例：

public class StringArrayExample2 {
    public static void main(String[] args) {
        // 在一行代码中完成声明、创建和初始化
        String[] cities = { "Beijing", "Shanghai", "Guangzhou", "Shenzhen" };
        // 打印整个数组
        // Arrays.toString() 是一个工具方法，可以方便地打印数组内容
        System.out.println(Arrays.toString(cities)); // 输出: [Beijing, Shanghai, Guangzhou, Shenzhen]
        // 访问单个元素
        System.out.println("The first city is: " + cities[0]); // 输出: The first city is: Beijing
    }
}

注意： 使用这种方式时，无需（也不能）使用 new 和指定长度，编译器会自动根据 中的元素个数来确定数组长度。

使用 new 关键字进行初始化

这种方法与方法二类似，但显式地使用了 new 关键字，在某些情况下，这种写法可能更清晰，尤其是在创建一个空数组或需要明确表达“创建”这个动作时。

语法：

String[] arrayName = new String[] { value1, value2, value3, ... };

代码示例：

public class StringArrayExample3 {
    public static void main(String[] args) {
        // 显式使用 new 关键字进行初始化
        String[] programmingLanguages = new String[] { "Java", "Python", "C++", "JavaScript" };
        System.out.println(Arrays.toString(programmingLanguages)); // 输出: [Java, Python, C++, JavaScript]
    }
}

重要区别： 这种 new 初始化的语法有一个非常重要的用途——可以在任何地方使用，而不只是在声明变量的那一行,在方法调用时直接传递一个新数组。

// 这是一个方法，它接收一个 String 数组
public static void printArray(String[] arr) {
    System.out.println(Arrays.toString(arr));
}
public static void main(String[] args) {
    // 在方法调用时直接创建并传递一个匿名数组
    printArray(new String[] { "Hello", "World" }); // 输出: [Hello, World]
}

而 的简写方式只能在声明变量时使用，不能用在其他地方，下面的代码是错误的：

// 错误的写法
printArray({ "Hello", "World" }); // 编译会报错

使用 Arrays 工具类（Java 8+）

如果你需要创建一个由特定值填充的数组，可以使用 java.util.Arrays 类中的 fill 方法。

代码示例：

import java.util.Arrays;
public class StringArrayExample4 {
    public static void main(String[] args) {
        // 1. 创建一个指定长度的数组
        String[] emptyArray = new String[5];
        // 2. 使用 Arrays.fill() 将所有元素填充为 "Unknown"
        Arrays.fill(emptyArray, "Unknown");
        System.out.println(Arrays.toString(emptyArray)); // 输出: [Unknown, Unknown, Unknown, Unknown, Unknown]
        // 3. 也可以填充数组的某个范围
        String[] partialArray = new String[5];
        Arrays.fill(partialArray, 1, 4, "Filled"); // 从索引 1 (包含) 到 4 (不包含) 填充
        System.out.println(Arrays.toString(partialArray)); // 输出: [null, Filled, Filled, Filled, null]
    }
}

使用 Java 8+ Stream API（高级用法）

对于更复杂的数组创建场景，比如从一个集合转换而来，或者使用函数式风格生成，可以使用 Stream API。

代码示例：

import java.util.Arrays;
import java.util.stream.Stream;
public class StringArrayExample5 {
    public static void main(String[] args) {
        // 1. 从一个 Stream 创建数组
        String[] fromStream = Stream.of("A", "B", "C").toArray(String[]::new);
        System.out.println("From Stream: " + Arrays.toString(fromStream)); // 输出: From Stream: [A, B, C]
        // 2. 从一个 List 转换为数组
        java.util.List<String> list = Arrays.asList("Apple", "Orange", "Grape");
        String[] fromList = list.toArray(new String[0]);
        System.out.println("From List: " + Arrays.toString(fromList)); // 输出: From List: [Apple, Orange, Grape]
    }
}

总结与对比

对于日常开发，方法二和方法三 是最需要掌握和频繁使用的。