Collections.fill方法用于将指定对象填充到List的所有已有元素位置，实现批量赋值。它不增加列表长度，仅替换现有元素，要求列表预先有元素，否则无效。相比循环，代码更简洁、语义更明确，适合初始化或重置场景。但填充引用类型时需警惕：所有位置共享同一实例，修改一处会影响全部，仅适用于不可变对象或确实需要共享的可变对象。结合nCopies、subList等操作可实现可变列表创建、局部填充等复杂策略，是集合操作中有用的辅助工具。
Collections.fill方法，在我看来，它就是Java集合框架里一个不起眼但又相当实用的“小工具”。它的核心作用，简单来说，就是用一个指定的对象去填充（或者说覆盖）一个
List中所有现有的元素。你可能觉得这事儿用个循环也能干，但它提供的简洁和潜在的效率，在特定场景下确实能让人眼前一亮。
解决方案
Collections.fill(List list, T obj)方法，它的设计初衷就是为了批量地将一个列表中的所有元素替换成同一个值。它会遍历你传入的
List，然后把每个位置上的元素都设为
obj。
比如，你有一个已经初始化好的
List，里面可能有一些旧数据，或者你只是想把它所有位置都重置成一个默认值。这时候，
fill就显得特别方便。
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CollectionsFillDemo {
public static void main(String[] args) {
// 场景一：初始化一个已知大小的列表，并填充默认值
List tasks = new ArrayList<>(5);
// 需要先确保列表有足够的容量，或者通过其他方式预填充
// Collections.fill要求列表已经有元素，所以通常会先add或者用其他方式创建
// 这里为了演示，我们先手动添加一些null或者占位符，或者直接用nCopies创建预设大小的列表
for (int i = 0; i < 5; i++) {
tasks.add(null); // 或者任何初始值
}
System.out.println("初始列表: " + tasks); // [null, null, null, null, null]
Collections.fill(tasks, "待处理");
System.out.println("填充后列表: " + tasks); // [待处理, 待处理, 待处理, 待处理, 待处理]
// 场景二：重置一个已有数据的列表
List scores = new ArrayList<>();
scores.add(90);
scores.add(85);
scores.add(92);
System.out.println("原始分数列表: " + scores); // [90, 85, 92]
Collections.fill(scores, 0); // 将所有分数重置为0
System.out.println("重置后分数列表: " + scores); // [0, 0, 0]
// 注意：Collections.fill要求列表是可变且已经有元素的。
// 如果你有一个空的ArrayList，直接fill是没用的，因为它没有可以“填充”的位置。
List emptyList = new ArrayList<>();
Collections.fill(emptyList, "hello"); // 不会改变emptyList，因为它没有元素
System.out.println("空列表填充后: " + emptyList); // []
// 如果想创建一个固定大小并填充的列表，Collections.nCopies更直接，但它返回的是不可变列表
// List fixedList = Collections.nCopies(3, "default"); // 返回不可变列表
// 如果需要可变，可以这样：
List mutableFixedList = new ArrayList<>(Collections.nCopies(3, "默认值"));
System.out.println("nCopies创建的可变列表: " + mutableFixedList); // [默认值, 默认值, 默认值]
}
} 可以看到，
Collections.fill让代码变得非常简洁，一眼就能看出它的意图。它并不创建新的列表，而是直接修改传入的列表。
Collections.fill
相比于传统循环，优势在哪里？
我个人在写代码的时候，尤其是在处理一些需要初始化或者重置列表的场景，会倾向于使用
Collections.fill。这倒不是说它在所有情况下都比
for循环快多少，毕竟底层实现可能也差不多是循环。但它的优势，在我看来，主要体现在几个方面：
首先是代码的简洁性和可读性。一行代码就能完成一个循环才能做的事情，这对于维护者来说，理解起来负担更小。一眼扫过去就知道：“哦，这个列表的所有元素都被设置成了某个值。”这比看到一个
for循环，然后里面有个
list.set(i, value)要直接得多。
其次，它表达的意图更明确。
fill这个词本身就带着“填充”的语义，它就是为了这个目的而生的。而
for循环则是一个更通用的控制结构，它可以做很多事情，所以它的意图需要通过循环体内部的代码来推断。
再者，虽然不是绝对，但
Collections工具类里的方法通常会经过JVM和JIT编译器的优化，可能会比我们手写的普通循环在某些特定环境下表现更好。虽然这在大多数业务场景下可能不是性能瓶颈，但聊胜于无嘛。
不过话说回来，
Collections.fill也并非万能。它要求列表已经有元素。如果你想创建一个空的列表然后填充，它就帮不上忙了。这时候你可能需要先用
add方法填充，或者用
Collections.nCopies来创建一个预填充的列表（但要注意
nCopies返回的是不可变列表，如果你需要修改，还得再包一层
ArrayList）。所以，选择哪个方法，还是要看具体的需求和场景。
Collections.fill
在处理引用类型时有哪些潜在的陷阱？
这绝对是使用
Collections.fill时一个需要特别注意的地方，也是我个人踩过坑的地方。当你用
Collections.fill去填充一个包含引用类型的列表时，它并不会为每个列表位置创建新的对象实例，而是将同一个对象的引用填充到列表的每个位置。
这意味着什么呢？如果这个被填充的对象是可变的（比如一个自定义的Java Bean），那么你通过列表中的任何一个索引去修改这个对象的状态，实际上会影响到列表中所有位置上的“相同”对象。因为它们都指向内存中的同一个实例。
举个例子：
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
class MyMutableObject {
private String name;
public MyMutableObject(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "MyMutableObject{" +
"name='" + name + '\'' +
'}';
}
}
public class CollectionsFillReferenceTrap {
public static void main(String[] args) {
List objects = new ArrayList<>(3);
for (int i = 0; i < 3; i++) {
objects.add(null); // 预填充，确保列表有3个位置
}
MyMutableObject defaultObject = new MyMutableObject("Default");
Collections.fill(objects, defaultObject);
System.out.println("填充后列表: " + objects);
// 输出: [MyMutableObject{name='Default'}, MyMutableObject{name='Default'}, MyMutableObject{name='Default'}]
// 尝试修改列表中的第一个对象
objects.get(0).setName("Modified");
System.out.println("修改第一个元素后列表: " + objects);
// 输出: [MyMutableObject{name='Modified'}, MyMutableObject{name='Modified'}, MyMutableObject{name='Modified'}]
// 发现所有元素都被修改了！这就是陷阱。
}
} 看到没？当你修改
objects.get(0)时，列表中的所有元素都“变”了。这在很多时候并不是我们想要的行为。如果你需要列表中的每个元素都是一个独立的可变对象实例，那么
Collections.fill就不适合了。你还是得老老实实地用循环，在循环内部每次都
new一个新的对象：
// 如果需要独立的实例 ListindependentObjects = new ArrayList<>(3); for (int i = 0; i < 3; i++) { independentObjects.add(new MyMutableObject("Default_" + i)); // 每次都创建新对象 } System.out.println("独立对象列表: " + independentObjects); independentObjects.get(0).setName("Modified_0"); System.out.println("修改第一个元素后独立对象列表: " + independentObjects); // 输出： // 独立对象列表: [MyMutableObject{name='Default_0'}, MyMutableObject{name='Default_1'}, MyMutableObject{name='Default_2'}] // 修改第一个元素后独立对象列表: [MyMutableObject{name='Modified_0'}, MyMutableObject{name='Default_1'}, MyMutableObject{name='Default_2'}]
所以，在使用
Collections.fill填充引用类型时，务必清楚你填充的是引用，而不是值拷贝。对于不可变对象（如
String、
Integer等包装类），或者你确实需要所有元素指向同一个实例时，这个方法依然高效且安全。
如何结合Collections.fill
与其他集合操作实现更复杂的初始化策略？
Collections.fill虽然功能单一，但它与其他集合操作结合起来，有时候能玩出一些有意思的花样，或者说，能够更优雅地解决一些初始化问题。这有点像积木，单个积木很简单，但组合起来就能搭出复杂的模型。
一个常见的场景是，我们可能需要一个特定大小的列表，并且希望它一开始就填充好默认值，但又要求这个列表是可变的。前面提到
Collections.nCopies可以创建固定大小的列表并填充，但它返回的是不可变的。这时候，
Collections.fill就能派上用场了。
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Arrays;
public class CollectionsFillCombinedUsage {
public static void main(String[] args) {
int size = 5;
String defaultValue = "待分配";
// 策略一：先用nCopies创建不可变列表，再包装成可变列表
// 这种方式虽然能得到一个预填充的可变列表，但如果nCopies的元素是可变对象，依然会有引用陷阱
List mutableListFromNCopies = new ArrayList<>(Collections.nCopies(size, defaultValue));
System.out.println("从nCopies创建的可变列表: " + mutableListFromNCopies);
mutableListFromNCopies.set(0, "已分配");
System.out.println("修改后: " + mutableListFromNCopies);
// 策略二：先创建固定大小的数组，转成List，再用fill
// 这种方式适用于需要预分配空间，然后进行批量填充的场景
List scores = new ArrayList<>(Arrays.asList(new Integer[size])); // 创建一个包含null的指定大小列表
System.out.println("包含null的列表: " + scores); // [null, null, null, null, null]
Collections.fill(scores, 0); // 用0填充所有位置
System.out.println("填充0后的列表: " + scores); // [0, 0, 0, 0, 0]
// 策略三：结合subList进行局部填充
// 假设我们有一个大列表，只想修改其中一部分区域的值
List allStatuses = new ArrayList<>(Arrays.asList("A", "B", "C", "D", "E", "F"));
System.out.println("原始状态列表: " + allStatuses);
// 填充索引1到3（不包含4）的元素为"PENDING"
Collections.fill(allStatuses.subList(1, 4), "PENDING");
System.out.println("局部填充后: " + allStatuses); // [A, PENDING, PENDING, PENDING, E, F]
// 策略四：创建并填充一个包含独立可变对象的列表（需要循环）
// 虽然fill不能直接创建独立的可变对象，但可以作为后续操作的基础
// 比如，先用fill填充一个占位符，然后循环替换
List complexObjects = new ArrayList<>(Collections.nCopies(size, null));
System.out.println("初始null列表: " + complexObjects);
for (int i = 0; i < size; i++) {
complexObjects.set(i, new MyMutableObject("Task_" + (i + 1))); // 循环创建独立对象
}
System.out.println("填充独立对象后: " + complexObjects);
complexObjects.get(0).setName("First Task Modified");
System.out.println("修改第一个对象后: " + complexObjects); // 只有第一个对象被修改
}
} 从上面的例子可以看出，
Collections.fill可以：
-
作为
Collections.nCopies
的补充，当你需要一个预填充但又可变的列表时。 -
与
Arrays.asList(new Type[size])
结合，快速创建一个指定大小且元素为null
的列表，然后再用fill
进行批量初始化。这种方式非常适合需要预留空间，然后统一设置默认值的场景。 -
操作
List.subList()
，实现对列表中局部区域的批量修改。这在处理大型数据集时，如果只有部分数据需要重置，会非常方便和高效。
所以，
Collections.fill不是一个孤立的方法，它更像是一个基础工具，可以灵活地嵌入到更复杂的集合操作流程中，帮助我们以更简洁、更具表达力的方式完成任务。只要我们清楚它的作用边界和潜在的陷阱，它就能成为代码库中一个趁手的利器。
