Question

I’ve been looking at a lot of different posts about permutations in Java, but none of them did fit my bill so I decided to post.

So I have 2 List<Integer>, and I need to generate all permutation pairs with no duplicates where one element of the pair is in the first list and the second one in the second list.

For example, if I have:

List<Integer> l1 = Arrays.asList(new Integer[] {1, 2, 3});
List<Integer> l1 = Arrays.asList(new Integer[] {2, 3, 4});

Then I want in output:

(1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4)

Note that (3, 2) is not here since I already have (2, 3)

I couldn’t find any library to do something even remotely close, I found that guava had something similar with Permutations but it seems to have been discontinued recently or something.

Also, I would like to not have to store the list in memory as it can be quite large, I only need to iterate on the pairs one at a time, so I’m trying to find ways to generate them on the fly. I was thinking to implement an Iterable<Pair> but I can’t seem to be able to write anything that looks efficient.

If you know libraries that already do this kind of stuff that would be very helpful as well !

Answer 1

How about

class Pair {
    private int x, y;

    Pair(int x, int y) {
        this.x = x;
        this.y = y;
    }

    @Override public int hashCode() {
        int result = 1;
        result = 31 * result + x;
        result = 31 * result + y;
        return result;
    }

    @Override public boolean equals(Object obj) {
        if (this == obj)              return true;
        if (!(obj instanceof Pair))   return false;
        Pair tmp = (Pair) obj;
        return (tmp.x == x && tmp.y == y) || (tmp.x == y && tmp.y == x);
    }

    public String toString() {
        return "(" + x + "," + y + ")";
    }
}

class Testt {
    public static void main(String[] args) {
        List<Integer> l1 = Arrays.asList( 1, 2, 3 );
        List<Integer> l2 = Arrays.asList( 2, 3, 4 );

        Set<Pair> set = new HashSet<Pair>();
        for (int i : l1)
            for (int j : l2)
                set.add(new Pair(i, j));

        System.out.println(set);
    }
}

Output

[(1,2), (1,3), (1,4), (2,2), (2,3), (2,4), (3,3), (3,4)]