核心概念

要理解 Java 数组的两个关键点：

1. 固定大小：数组一旦被创建，其大小（长度）就不能再改变。
2. 同构性：一个数组中只能存储一种类型的数据，对于 String[]，它只能存储 String 对象。

基本定义和初始化

这是最直接、最常见的方式。

先声明，后分配空间

这种方式分两步：先声明数组变量，再使用 new 关键字为数组分配内存。

// 1. 声明一个可以存储 String 对象的数组，名为 names
String[] names;
// 2. 使用 new 关键字创建一个长度为 3 的 String 数组
// 数组中的每个元素都是 null
names = new String[3];

声明并分配空间（一步完成）

将上述两步合并,更简洁。

// 声明并创建一个长度为 5 的 String 数组
String[] fruits = new String[5];

声明、分配空间并初始化（最常用）

在创建数组的同时,直接为其赋值，这种方式最直观，代码可读性高。

// 创建一个包含 3 个元素的 String 数组
String[] languages = new String[]{"Java", "Python", "JavaScript"};
// 或者使用更简洁的语法（推荐）
String[] frameworks = {"Spring", "Django", "React"};

注意：使用简化的 语法时，不能在声明时再指定数组长度，String[] frameworks = new String[3] {"Spring", "Django", "React"}; 是错误的。

访问和修改数组元素

数组使用 索引 来访问元素，索引从 0 开始。

String[] cities = {"Beijing", "Shanghai", "Guangzhou"};
// 1. 访问元素
// 获取第一个元素 (索引为 0)
String firstCity = cities[0]; // firstCity 的值是 "Beijing"
// 获取最后一个元素 (索引为 length - 1)
String lastCity = cities[cities.length - 1]; // lastCity 的值是 "Guangzhou"
// 2. 修改元素
// 将索引为 1 的元素 "Shanghai" 修改为 "Shenzhen"
cities[1] = "Shenzhen";
// 修改后，cities 数组变为 {"Beijing", "Shenzhen", "Guangzhou"}

遍历数组

有三种主要的方法来遍历数组。

经典的 for 循环

通过索引来访问每个元素,适用于需要知道当前元素索引的场景。

String[] tools = {"Maven", "Git", "Jenkins"};
System.out.println("使用 for 循环遍历:");
for (int i = 0; i < tools.length; i++) {
    System.out.println("工具 " + i + ": " + tools[i]);
}

增强型 for 循环 (for-each loop)

这是最简洁、最推荐的遍历方式，当你只需要数组中的元素值，而不关心其索引时使用。

String[] frameworks = {"Spring", "Django", "React"};
System.out.println("\n使用 for-each 循环遍历:");
for (String framework : frameworks) {
    System.out.println("框架: " + framework);
}

使用 Java 8+ 的 Stream API

这是一种更现代、功能更强大的方式，可以进行链式操作，如过滤、排序等。

String[] technologies = {"Java", "Python", "Go", "Rust"};
System.out.println("\n使用 Stream API 遍历并过滤:");
// 1. 创建一个流
// 2. 过滤出长度大于 3 的字符串
// 3. 遍历并打印
Arrays.stream(technologies)
      .filter(s -> s.length() > 3)
      .forEach(System.out::println);
// 输出:
// Java
// Python

注意：使用 Stream API 需要导入 java.util.Arrays 包。

常用方法和工具类

java.util.Arrays 类提供了许多用于操作数组（包括 String 数组）的静态方法。

import java.util.Arrays;
String[] names = {"Alice", "Bob", "Charlie"};
// 1. Arrays.toString() - 将数组转换为字符串形式，方便打印
System.out.println("数组内容: " + Arrays.toString(names));
// 输出: 数组内容: [Alice, Bob, Charlie]
// 2. Arrays.sort() - 对数组进行排序（按字母顺序）
Arrays.sort(names);
System.out.println("排序后: " + Arrays.toString(names));
// 输出: 排序后: [Alice, Bob, Charlie]
// 3. Arrays.copyOf() - 复制数组，可以指定新长度
String[] namesCopy = Arrays.copyOf(names, 5);
System.out.println("复制后的数组: " + Arrays.toString(namesCopy));
// 输出: 复制后的数组: [Alice, Bob, Charlie, null, null]
// 如果新长度大于原长度，多出的元素会被填充为 null
// 4. Arrays.equals() - 比较两个数组内容是否相同
String[] names2 = {"Alice", "Bob", "Charlie"};
boolean isEqual = Arrays.equals(names, names2);
System.out.println("两个数组是否相等? " + isEqual);
// 输出: 两个数组是否相等? true

重要注意事项

空指针异常 (NullPointerException)

当你尝试使用一个值为 null 的数组，或者访问数组中为 null 的元素时，会抛出 NullPointerException。

// 场景1: 数组本身为 null
String[] myArray = null;
// myArray.length; // 抛出 NullPointerException
// 场景2: 数组已创建，但某个元素未被初始化，为 null
String[] myArray2 = new String[3];
// myArray2[0].toUpperCase(); // 抛出 NullPointerException

最佳实践：在访问数组元素前，最好进行非空检查。

if (myArray2 != null && myArray2[0] != null) {
    System.out.println(myArray2[0].toUpperCase());
}

数组长度不可变

一旦数组创建完成,它的长度就是固定的，如果你需要一个可以动态改变大小的集合，应该使用 ArrayList。

// String[] 是固定大小的
String[] fixedArray = new String[2];
fixedArray[0] = "A";
fixedArray[1] = "B";
// fixedArray[2] = "C"; // 抛出 ArrayIndexOutOfBoundsException
// ArrayList<String> 是动态大小的
import java.util.ArrayList;
ArrayList<String> dynamicList = new ArrayList<>();
dynamicList.add("A");
dynamicList.add("B");
dynamicList.add("C"); // 这是允许的

希望这份详细的指南能帮助你全面理解 Java 中 String 数组的定义和使用！