IntelliJ IDEA 警告“Immutable object is modified”的问题排查与解决方法

import java.util.List;
import java.util.ArrayList;

public class ImmutableTrap {
    public static void main(String[] args) {
        // 场景 1：使用 Java 9 List.of 创建不可变列表
        List<String> distinctList = List.of("Apple", "Banana", "Cherry");

        // ❌ 触发警告：Immutable object is modified
        // 运行时将抛出 UnsupportedOperationException
        distinctList.add("Date"); 
        
        // ❌ 触发警告
        distinctList.remove(0);
        
        // ❌ 触发警告
        distinctList.set(0, "Orange");
    }
}

// 简化版的 JDK 内部实现逻辑
class ImmutableArrayList<E> extends AbstractList<E> {
    private final E[] elements;

    @Override
    public boolean add(E e) {
        throw new UnsupportedOperationException("Not supported");
    }

    @Override
    public E remove(int index) {
        throw new UnsupportedOperationException("Not supported");
    }
    
    @Override
    public E set(int index, E element) {
        throw new UnsupportedOperationException("Not supported");
    }
    
    // ... 其他修改方法同理
}

List<String> immutableList = List.of("A", "B", "C");

// ✅ 正确做法：构造一个新的 ArrayList，将不可变集合作为参数传入
List<String> mutableList = new ArrayList<>(immutableList);

// 现在可以安全地进行修改
mutableList.add("D");
mutableList.remove("A");

// 如果需要，最后可以再转回不可变集合（视需求而定）
List<String> finalList = List.copyOf(mutableList);

// ❌ 错误的设计意图
// List<String> list = List.of("A", "B", "C"); 

// ✅ 正确的设计意图：直接使用 ArrayList 初始化
List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
// 或者 Java 8+ Stream
List<String> list = Stream.of("A", "B", "C").collect(Collectors.toList());

list.add("D"); // 安全

List<String> original = List.of("Apple", "Banana", "Cherry");

// 需求：添加一个元素
// ❌ 不要尝试 original.add("Date")
// ✅ 使用 Stream 生成新列表
List<String> newList = Stream.concat(
    original.stream(), 
    Stream.of("Date")
).collect(Collectors.toUnmodifiableList());

// 需求：过滤元素
List<String> filteredList = original.stream()
    .filter(f -> !f.equals("Banana"))
    .collect(Collectors.toUnmodifiableList());

val immutableList = listOf("A", "B", "C")
// immutableList.add("D") // 编译报错

// 转换为可变列表
val mutableList = immutableList.toMutableList()
mutableList.add("D")

List<String> list = Arrays.asList("A", "B", "C");

list.set(0, "X"); // ✅ 允许：可以修改现有元素的值
list.add("D");    // ❌ 抛出 UnsupportedOperationException：不能改变大小
list.remove(0);   // ❌ 抛出 UnsupportedOperationException

List<String> source = new ArrayList<>();
source.add("A");

List<String> readOnly = Collections.unmodifiableList(source);

// 虽然 readOnly 不能直接修改，但如果修改 source，readOnly 也会变！
source.add("B"); 

System.out.println(readOnly); // 输出：[A, B]

List<String> immutable = List.of("A", "B", "C", "D");
List<String> sub = immutable.subList(0, 2);

sub.add("E"); // ❌ 同样抛出异常，因为底层 backed by 不可变集合

/**
 * 处理用户列表。
 * @param users 输入列表，保证不会被本方法修改
 */
public void processUsers(List<User> users) {
    // 如果需要修改，内部自行 copy
    List<User> workingSet = new ArrayList<>(users);
    // ... 操作 workingSet
}

public class Order {
    private final List<OrderItem> items;

    public Order(List<OrderItem> items) {
        // 构造函数中进行防御性拷贝，并转为不可变存储
        this.items = List.copyOf(items); 
    }

    public List<OrderItem> getItems() {
        // 返回不可变视图，或者直接返回内部引用（因为内部已经是不可变的）
        return items; 
    }
    
    // 提供明确的方法来创建新状态，而不是直接修改
    public Order addItem(OrderItem newItem) {
        List<OrderItem> newItems = new ArrayList<>(this.items);
        newItems.add(newItem);
        return new Order(newItems); // 返回新对象（不可变对象模式）
    }
}

@Test
public void testMethodDoesNotModifyInput() {
    List<String> input = new ArrayList<>(List.of("A", "B"));
    List<String> originalContent = new ArrayList<>(input);
    
    myService.process(input);
    
    assertEquals(originalContent, input, "输入列表不应被修改");
}