Java中对象能否同时属于数组与ArrayList？修改后为何不同步？

问题根源 #

你当前代码的同步失效，本质是两个核心误解：

1. String是不可变类型：执行strArray[2] = "Monkey"时，并不是修改原有"three"对象的内容，而是把数组第2位的引用替换成了全新的"Monkey"对象。ArrayList里存储的还是原来"three"的引用，自然不会同步变化。
2. ArrayList存储的是引用副本：你把数组元素的引用添加到ArrayList时，只是复制了一份引用存入集合。数组和ArrayList各自持有独立的引用集合，当数组替换元素引用时，ArrayList的引用不会自动更新。

解决方案：使用可变对象共享引用 #

要实现修改一方另一方同步变化，必须让数组和ArrayList持有同一个可变对象的引用，通过修改对象内部状态而非替换引用来同步变更。

方案1：自定义可变字符串容器

import java.util.ArrayList;

class MutableString {
    private String value;

    public MutableString(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return value;
    }
}

public class ArrArrList {
    public static void main(String[] args) {
        ArrayList<MutableString> arr = new ArrayList<>();
        
        MutableString[] strArray = new MutableString[3];
        strArray[0] = new MutableString("one");
        strArray[1] = new MutableString("two");
        strArray[2] = new MutableString("three");

        // 存入同一个可变对象的引用
        arr.add(strArray[0]);
        arr.add(strArray[1]);
        arr.add(strArray[2]);

        System.out.print("ArrayList after all insertions: ");
        display(arr); // 输出 one two three
        
        System.out.print("Array after all insertions: ");
        for (MutableString ms : strArray) {
            System.out.print(ms + " "); // 输出 one two three
        }
        System.out.println();

        // 修改可变对象的内部状态
        strArray[2].setValue("Monkey");

        System.out.print("ArrayList after change: ");
        display(arr); // 输出 one two Monkey

        System.out.print("Array after change: ");
        for (MutableString ms : strArray) {
            System.out.print(ms + " "); // 输出 one two Monkey
        }
        System.out.println();
    }

    public static void display(ArrayList<MutableString> arr) {
        for (MutableString ms : arr) {
            System.out.print(ms + " ");
        }
        System.out.println();
    }
}

方案2：使用JDK自带的AtomicReference

无需自定义类，用AtomicReference包装字符串实现可变：

import java.util.ArrayList;
import java.util.concurrent.atomic.AtomicReference;

public class ArrArrList {
    public static void main(String[] args) {
        ArrayList<AtomicReference<String>> arr = new ArrayList<>();
        
        AtomicReference<String>[] strArray = new AtomicReference[3];
        strArray[0] = new AtomicReference<>("one");
        strArray[1] = new AtomicReference<>("two");
        strArray[2] = new AtomicReference<>("three");

        arr.add(strArray[0]);
        arr.add(strArray[1]);
        arr.add(strArray[2]);

        System.out.print("ArrayList after all insertions: ");
        display(arr); // 输出 one two three
        
        System.out.print("Array after all insertions: ");
        for (AtomicReference<String> ref : strArray) {
            System.out.print(ref.get() + " "); // 输出 one two three
        }
        System.out.println();

        // 修改包装对象的内部值
        strArray[2].set("Monkey");

        System.out.print("ArrayList after change: ");
        display(arr); // 输出 one two Monkey

        System.out.print("Array after change: ");
        for (AtomicReference<String> ref : strArray) {
            System.out.print(ref.get() + " "); // 输出 one two Monkey
        }
        System.out.println();
    }

    public static void display(ArrayList<AtomicReference<String>> arr) {
        for (AtomicReference<String> ref : arr) {
            System.out.print(ref.get() + " ");
        }
        System.out.println();
    }
}

核心逻辑总结 #

数组和ArrayList要同步变化，必须共享同一个可变对象的引用，通过修改对象内部状态实现同步。如果使用不可变类型（如String），替换引用的操作永远无法让两边同步，因为两边持有的是完全独立的对象引用。

内容的提问来源于stack exchange，提问作者JSNoob