1

我有如下的类 SpeexRunner，构造函数接受两个参数一个布尔变量和一个LinkedList<short[]>. 如下 ：-

public class SpeexRunner implements Runnable {
    public boolean stopThread;
    LinkedList<short[]> dataList;

    public SpeexRunner(boolean val_stopThread, LinkedList<short[]> dataRef){
        this.stopThread = val_stopThread;
        dataList = dataRef;
    }
    @Override
    public void run() {
     //add objects in dataList;
     // change / remove dataList Objects
    }
}

我的问题是：-如果我更改 run() 中的 dataList，这些更改会反映到在其他地方声明的原始列表吗？

4

4 回答 4

5

如果我更改 run() 中的 dataList，这些更改是否会反映到在其他地方声明的原始列表中？

是的。您的构造函数接收对列表的引用，而不是它的副本。如果要复制它，则必须使用LinkedList 复制构造函数。然后，您将拥有自己的列表副本。但请注意，两个列表上的条目仍然是共享的，因为条目是数组 ( short[])，并且数组是通过引用存储的。

这也许是最好的例子：

import java.util.*;

public class ListExample {
    public static final void main(String[] args) {
        List<short[]> list;

        // Direct use (no copies)
        list = new LinkedList<short[]>();
        list.add(new short[] { 0, 0, 0 });
        System.out.println("list.size() before direct use: " + list.size());
        System.out.println("list.get(0)[0] before direct use: " + list.get(0)[0]);
        new DirectUser(list).doSomething();
        System.out.println("list.size() after direct use: " + list.size());
        System.out.println("list.get(0)[0] after direct use: " + list.get(0)[0]);
        // Output, note how both the list and its contents have been changed:
        // list.size() before direct use: 1
        // list.get(0)[0] before direct use: 0
        // list.size() after direct use: 2
        // list.get(0)[0] after direct use: 1

        // Copying the list, but note that the entries are shared by both lists:
        list = new LinkedList<short[]>();
        list.add(new short[] { 0, 0, 0 });
        System.out.println("list.size() before copy-list use: " + list.size());
        System.out.println("list.get(0)[0] before copy-list use: " + list.get(0)[0]);
        new CopyListUser(list).doSomething();
        System.out.println("list.size() after copy-list use: " + list.size());
        System.out.println("list.get(0)[0] after copy-list use: " + list.get(0)[0]);
        // Output, note how our list didn't change (it doesn't have a new entry), but
        // the entry at index 0 *was* changed:
        // list.size() before copy-list use: 1
        // list.get(0)[0] before copy-list use: 0
        // list.size() after copy-list use: 1
        // list.get(0)[0] after copy-list use: 1

        // "Deep" copying, both the list and its entries:
        list = new LinkedList<short[]>();
        list.add(new short[] { 0, 0, 0 });
        System.out.println("list.size() before deep-copy use: " + list.size());
        System.out.println("list.get(0)[0] before deep-copy use: " + list.get(0)[0]);
        new DeepCopyUser(list).doSomething();
        System.out.println("list.size() after deep-copy use: " + list.size());
        System.out.println("list.get(0)[0] after deep-copy use: " + list.get(0)[0]);
        // Output, note that neither the list nor its entries was affected by the call:
        // list.size() before deep-copy use: 1
        // list.get(0)[0] before deep-copy use: 0
        // list.size() after deep-copy use: 1
        // list.get(0)[0] after deep-copy use: 0


        System.exit(0);
    }

    static class DirectUser {
        List<short[]> items;

        DirectUser(List<short[]> items) {
            // DirectUser doesn't copy the list
            this.items = items;
        }

        void doSomething() {
            this.items.get(0)[0] = 1;
            this.items.add(new short[] { 2, 2, 2 });
        }
    }

    static class CopyListUser {
        List<short[]> items;

        CopyListUser(List<short[]> items) {
            // CopyListUser copies the list, but both lists still share items
            this.items = new LinkedList<short[]>(items);
        }

        void doSomething() {
            this.items.get(0)[0] = 1;
            this.items.add(new short[] { 2, 2, 2 });
        }
    }

    static class DeepCopyUser {
        List<short[]> items;

        DeepCopyUser(List<short[]> items) {
            // DeepCopyUser copies the list AND each entry
            this.items = new LinkedList<short[]>();
            for (short[] entry : items) {
                this.items.add(Arrays.copyOf(entry, entry.length));
            }
        }

        void doSomething() {
            this.items.get(0)[0] = 1;
            this.items.add(new short[] { 2, 2, 2 });
        }
    }
}

当DirectUser使用列表时，在我们的调用代码中，我们看到列表（因为它变长了）和它的内容（第一个条目的第一个插槽从 更改0为1）都发生了变化。

使用CopyListUser它时，它会复制列表，因此我们在调用代码中没有看到列表有任何变化（它没有变长）。但是我们确实看到了第一个条目的变化（因为两个列表共享同一个数组对象）——第一个插槽从0变为1再次。

使用DeepCopyUser它时，它会复制列表和每个条目的副本，因此事情完全完全断开。我们的调用代码没有看到列表或其项目的任何更改。

于 2012-04-17T11:16:44.773 回答
3

如果我更改 run() 中的 dataList，这些更改是否会反映到在其他地方声明的原始列表中？

简短的回答：是的。

稍微长一点的答案：是的，因为在 Java 中参数总是通过引用传递。

（您可能会使用LinkedList禁止或忽略更改的（假设的）子类。在这种情况下，尝试的更改将导致异常或无效。但是，这将是不正当的......）

于 2012-04-17T11:16:53.853 回答
2

是的，它将作为线程引用列表，而不是列表的副本。请注意，LinkedList不同步：

如果多个线程同时访问一个链表，并且至少有一个线程在结构上修改了链表，则必须对外同步。

于 2012-04-17T11:16:51.943 回答
2

如果您将元素添加到列表中/从列表中删除元素，则这些更改将从您的其余代码中可见。请注意，如果您使用多个线程，则需要使用同步来保证更改是可见的。

另一方面，如果您不希望更改逃离您的类，您可以在构造函数中创建一个新列表并将所有项目添加到原始列表中。在这种情况下，对列表的更改将不会从外部看到，但如果您对列表中的项目进行更改，这些更改将会显示。

于 2012-04-17T11:17:02.557 回答