如何在Java中置换通用列表？

Question

I am trying to write a function to permute a generic list, but something very strange is happening. The following code-structure works if I replace all the lists with arrays, but as it is the code simply prints out [1, 2, 3] six times. Why is this? I think it has something to do with pass by value vs pass by reference.

//Main.java
import java.util.ArrayList;
import java.util.Set;
import java.util.List;

public class Main {

    public static void main (String ... args) {
        ArrayList<Integer> AL = new ArrayList<Integer>();
        AL.add(1);
        AL.add(2);
        AL.add(3);

        Permute<Integer> perm = new Permute<Integer>();
        Set<List<Integer>> set = perm.listPermutations(AL);

        for (List<Integer> lst : set) {
            System.out.println(lst);
        }
    }
}

//Permute.java
import java.util.List;
import java.util.Set;
import java.util.HashSet;

public class Permute<E> {

    public Set<List<E>> listPermutations(List<E> lst) {
        Set<List<E>> perms = new HashSet<List<E>>();
        permute(lst, 0, perms);
        return perms;
    }

    private void permute(List<E> lst, int start, Set<List<E>> perms) {
        if (start >= lst.size()) {
            // nothing left to permute 
            perms.add(lst);
        }

        for (int i = start; i < lst.size(); i++) {
            // swap elements at locations start and i
            swap(lst, start, i);
            permute(lst, start + 1, perms);
            swap(lst, start, i);
        }
    }

    private void swap(List<E> lst, int x, int y) {
        E temp = lst.get(x);
        lst.set(x, lst.get(y));
        lst.set(y, temp);
    }
}

Answer 1

When you call permute , you never create a new List . lst is a reference to the List , and that reference gets passed around to all your recursive invocations, and the result is that you add the same reference to the set 6 times. Normally, adding the same reference to the set 6 times means that your Set will contain only one element.

The reason it appears to have six elements at all is because you modify the contents of the List after you add it to the hash, something you're never supposed to do with a HashMap or HashSet . If you add an object reference to a HashMap or HashSet , and later modify the object in a way that changes the hash code, you will screw up the workings of the hash.

Because of that, somehow the same reference got added to the set six times with six different hash codes. But they're still all a reference to the same List , which means that when you print them out, they will all appear the same.

You need to make a copy of the List before you call permute recursively. If it's OK for permute to know that the List is an ArrayList , you can say something like

List<E> newList = new ArrayList<>(lst);

and then do the first swap using newList , and then pass newList to your recursive invocation. (The second swap is probably no longer needed.)

If you want to create a newList whose type is the same type as the source list ... I'm not sure if there's a simple way to do that, other than by using reflection.