Question

I have class SpeexRunner as follows, The constructor of takes two arguments a boolean variable and a LinkedList<short[]>. As follows :-

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
    }
}

My Question is:- If I change the dataList inside the run(), will the changes be reflected to the original list which is declared somewhere else ?

Answer 1

If I change the dataList inside the run(), will the changes be reflected to the original list which is declared somewhere else ?

Yes. Your constructor receives a reference to the list, not a copy of it. If you want to copy it, you’ll have to use the LinkedList copy constructor. Then you’ll have your own copy of the list. But note that the entries on the two lists are still shared, because the entries are arrays (short[]), and arrays are stored by reference.

This is perhaps best demonstrated by example:

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 });
        }
    }
}

When DirectUser used the list, in our calling code we saw changes both to the list (in that it got longer) and to its contents (the first entry’s first slot changed from 0 to 1).

When CopyListUser used it, it made a copy of the list, so we didn’t see any change to our list in our calling code (it didn’t get longer). But we did see the change to the first entry (because both lists shared the same array object) — the first slot changed from 0 to 1 again.

When DeepCopyUser used it, it made a copy of the list and a copy of each entry, so things were completely and totally disconnected. No changes to the list or to its items were seen by our calling code.