Java 实例 – 数组填充（实战指南）

Java 实例 – 数组填充：从零开始掌握数据初始化技巧

在 Java 编程中，数组是存储一组相同类型数据的基本结构。但你是否遇到过这样的场景：需要快速为一个数组填充默认值，比如全为 0、全为 null，或者某个特定的字符串？这时候，Arrays.fill() 方法就显得格外重要。今天我们就来深入聊聊 Java 实例 – 数组填充，带你掌握这一实用技巧，让数据初始化变得高效又优雅。

数组填充看似简单，但背后涉及内存操作、类型兼容性以及性能优化等知识点。尤其对于初学者来说，直接使用 new int[10] 虽然能创建数组，但默认值是 0，无法满足复杂需求。而 Arrays.fill() 正是解决这类问题的利器。

让我们从基础开始，逐步深入。

什么是数组填充？为什么需要它？

数组填充，简单来说就是将一个数组中的所有元素设置为同一个指定值。这在实际开发中非常常见。比如：

• 初始化成绩数组，所有学生初始分数设为 0；
• 创建状态数组，表示系统中所有模块的“未启动”状态；
• 预分配缓冲区，用于网络通信或文件读写。

如果不使用填充方法，你可能需要写一个循环，逐个赋值：

int[] scores = new int[50];
for (int i = 0; i < scores.length; i++) {
    scores[i] = 0; // 手动赋值，效率低且易出错
}

而使用 Arrays.fill()，代码变得简洁明了：

int[] scores = new int[50];
Arrays.fill(scores, 0); // 一行搞定，清晰高效

这就是 Java 实例 – 数组填充的魅力所在：用一行代码完成原本需要多行循环的任务。

使用 Arrays.fill() 的基本语法与参数说明

Arrays.fill() 是 java.util.Arrays 类中的静态方法，用于将数组中指定范围的元素设置为某个值。它的主要重载形式如下：

public static void fill(int[] a, int val)
public static void fill(double[] a, double val)
public static void fill(Object[] a, Object val)
public static void fill(int[] a, int fromIndex, int toIndex, int val)

参数说明：

• a：目标数组；
• val：要填充的值；
• fromIndex：起始索引（包含）；
• toIndex：结束索引（不包含）。

注意：fromIndex 和 toIndex 必须满足 0 <= fromIndex <= toIndex <= a.length，否则会抛出 ArrayIndexOutOfBoundsException。

我们来看一个完整的例子：

import java.util.Arrays;

public class ArrayFillExample {
    public static void main(String[] args) {
        // 创建一个长度为 8 的整型数组
        int[] numbers = new int[8];

        // 使用 fill 方法将整个数组填充为 99
        Arrays.fill(numbers, 99);

        // 输出结果
        System.out.println(Arrays.toString(numbers));
        // 输出：[99, 99, 99, 99, 99, 99, 99, 99]
    }
}

💡 小贴士：Arrays.toString() 是一个方便的方法，用于将数组转换为字符串格式，便于打印和调试。

按指定区间填充：精准控制填充范围

在某些场景下，你并不需要填充整个数组，而是只希望修改其中的一部分。这时，使用带范围参数的 fill() 方法就非常有用。

比如，你有一个 10 个学生的成绩数组，前 5 个学生刚参加模拟考试，需要将他们的成绩设为 0，而后 5 个学生尚未考试，保持为默认值。

import java.util.Arrays;

public class PartialFillExample {
    public static void main(String[] args) {
        // 原始数组，初始值为 0
        int[] scores = new int[10];

        // 只填充前 5 个元素（索引 0 到 4）
        Arrays.fill(scores, 0, 5, 0);

        // 输出结果
        System.out.println(Arrays.toString(scores));
        // 输出：[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    }
}

这里 Arrays.fill(scores, 0, 5, 0) 表示：从索引 0 开始，到索引 5（不包含），将这些位置的值设为 0。注意，toIndex 是“不包含”的，这是 Java 中常见的边界处理方式。

📌 重要提醒：toIndex 必须大于等于 fromIndex，且不能超过数组长度，否则会抛出异常。

填充不同类型数组的实践案例

Arrays.fill() 支持多种基本类型和引用类型，下面通过几个真实场景来演示。

1. 填充字符串数组

import java.util.Arrays;

public class StringArrayFill {
    public static void main(String[] args) {
        // 创建一个字符串数组，长度为 6
        String[] names = new String[6];

        // 将所有元素填充为 "未分配"
        Arrays.fill(names, "未分配");

        // 输出结果
        System.out.println(Arrays.toString(names));
        // 输出：[未分配, 未分配, 未分配, 未分配, 未分配, 未分配]
    }
}

⚠️ 注意：虽然字符串是对象，但 fill 填充的是引用，所有元素都指向同一个字符串对象 "未分配"。如果后续修改其中一个值，会影响其他元素。若需独立对象，应使用 new String("未分配") 等方式创建。

2. 填充布尔数组

import java.util.Arrays;

public class BooleanArrayFill {
    public static void main(String[] args) {
        boolean[] active = new boolean[10];

        // 将所有状态设为 false，表示“未激活”
        Arrays.fill(active, false);

        System.out.println(Arrays.toString(active));
        // 输出：[false, false, false, false, false, false, false, false, false, false]
    }
}

3. 填充对象数组（如自定义类）

import java.util.Arrays;

class User {
    String name;
    int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{name='" + name + "', age=" + age + "}";
    }
}

public class ObjectArrayFill {
    public static void main(String[] args) {
        User[] users = new User[3];

        // 填充为 null，表示“未初始化”
        Arrays.fill(users, null);

        System.out.println(Arrays.toString(users));
        // 输出：[null, null, null]
    }
}

📌 注意：对于对象数组，Arrays.fill() 只填充引用，不会创建新对象。因此，若想填充为新对象，需循环创建。

性能对比：循环 vs Arrays.fill()

我们来做一个简单性能测试，比较手动循环和 Arrays.fill() 的效率。

import java.util.Arrays;

public class PerformanceTest {
    public static void main(String[] args) {
        int[] data = new int[1000000];

        // 方法一：使用循环填充
        long start = System.nanoTime();
        for (int i = 0; i < data.length; i++) {
            data[i] = 1;
        }
        long time1 = System.nanoTime() - start;

        // 方法二：使用 Arrays.fill()
        Arrays.fill(data, 1);
        long time2 = System.nanoTime() - start;

        System.out.println("循环填充耗时：" + time1 + " 纳秒");
        System.out.println("Arrays.fill 耗时：" + time2 + " 纳秒");
    }
}

在大多数情况下，Arrays.fill() 的性能更优，因为它底层使用了优化的内存复制机制（如 System.arraycopy()），并且 JVM 会对它进行内联优化。

常见误区与最佳实践

❌ 误区一：误以为 fill 会创建新对象

String[] arr = new String[3];
Arrays.fill(arr, "hello");
// 所有元素都指向同一个 "hello" 字符串对象

如果后续执行 arr[0] = "world"，只会改变第一个元素，其他仍为 "hello"。这是正确的，但很多人误以为 fill 会生成副本。

✅ 最佳实践：明确用途，合理选择填充方式

✅ 建议：结合 Arrays.fill() 与 Arrays.sort() 使用

在某些算法中，先填充再排序是常见模式：

int[] result = new int[10];
Arrays.fill(result, 5); // 先填充为 5
Arrays.sort(result);   // 排序后仍是 [5, 5, ..., 5]

虽然排序无意义，但结构清晰，便于维护。

总结

通过本文的深入讲解，相信你已经掌握了 Java 实例 – 数组填充的核心用法。从基础语法到高级应用场景，我们不仅学习了 Arrays.fill() 的使用方法，还理解了其背后的性能优势与常见陷阱。

记住，编程不仅仅是“让程序跑起来”，更是“让代码清晰、高效、可维护”。Arrays.fill() 正是这样一个“小而美”的工具，它让数组初始化变得简洁优雅。

无论你是初学者还是有一定经验的开发者，都应该将 Arrays.fill() 纳入你的工具箱。它不仅是 Java 基础中的经典用法，更是一种编程习惯的体现。

下次当你需要初始化数组时，别再写长长的 for 循环了，直接用 Arrays.fill()，让代码更简洁、运行更高效。