How to get the combination of elements from the list as shown

Question

I have a List<int[]> as index_position:int[] values

input:

index 0:{1,2} 
index 1:{1,3,5} 
index 2:{2}

How do I get the following combination in Java with or without using Lambdas.

Step1: Find all such combinations

[{1,1,2}, {1,3,2}, {1,5,2}, {2,1,2}, {2,3,2}, {2,5,2}]

-> 

Step2: Remove duplicates from the obtanied combination

[{1,2}, {1,3,2}, {1,5,2}, {2,1}, {2,3}, {2,5}]

"want to do in each step like generate all n element subsets from n arrays >where first element comes from first array, second from second array..., >remove duplicates from each of resulting subsets."

It is not required to further reduce

[{1,2}, {1,2}] 

to

[{1,2}] 

or

[{1,2},{2,1}] 

to

[{1,2}] / [{2,1}]

but will not affect the result in my case if done as well.

Answer 1

What you are asking seems to be cartesian product of N sets (Set1 x Set2 x ... x SetN).

Unfortunately there is no standard method in Java which would allow us to build one easily, but with little help of Guava and its Sets.cartesianProduct method this task seems quite easy.

Only condition is that we need to provide as its argument List<Set<..>>.
Because of that this answer is based on assumption that each int[] is can be treated as set, which means that its values must be unique. Actually to be more precise if index 0 will be {1,2,1} or {1,2,2} it will be processed as set {1,2}.

Here is example with List<Set<Integer>> with your current data
(toList is statically imported Collections.toList() method, similarly toSet) :

//part 0: preparing data
List<Set<Integer>> sets = new ArrayList<>(
            Arrays.asList(
                new HashSet<>(Arrays.asList(1, 2)), 
                new HashSet<>(Arrays.asList(1, 3, 5)),
                new HashSet<>(Arrays.asList(2))
            )
        );
sets.forEach(System.out::println);
System.out.println("-----------------");

//part 1: calculating cartesian products
Set<List<Integer>> cartesianProducts = Sets.cartesianProduct(sets);
System.out.println(cartesianProducts);
System.out.println("-----------------");

//part 2
List<List<Integer>> noDuplicatesInProducts = cartesianProducts
        .stream()//iterate over each cartesian product
        .map(product ->  product.stream()
                          .distinct()//remove duplicate values
                          .collect(toList())//store updated product as list
        ).collect(toList());//store all products as list
System.out.println(noDuplicatesInProducts);

Output:

[1, 2]
[1, 3, 5]
[2]
-----------------
[[1, 1, 2], [1, 3, 2], [1, 5, 2], [2, 1, 2], [2, 3, 2], [2, 5, 2]]
-----------------
[[1, 2], [1, 3, 2], [1, 5, 2], [2, 1], [2, 3], [2, 5]]

---

If you are looking for a way to convert List<int[]> to List<Set<Integer>> here is one example:

private static List<Set<Integer>> convert(List<int[]> list) {
    return list
            .stream()
            .map(arr -> 
                    IntStream.of(arr)
                    .mapToObj(Integer::valueOf)// same as .boxed()
                    .collect(toSet())
            ).collect(toList());
}

Answer 2

Edit: At the time, this answer was given, the question was vague and suggested a 'remove duplicates' problem. I'll keept this answer though as it might contain helpful information to others.

Its hard to tell an exact solution to your problem as you don't properly describe the input and the wanted output. Just posting one example isn't enough.

So let's assume the following:

• Input: A list of integer arrays (List<int[]>).

• Output: A list of integer arrays (List<int[]>), where the n-th array contains the values of the n-th array of the input list, but with duplicates removed.

Copying the items of the input list into a new output list is simple:

List<int[]> output = new ArrayList<>(input.size());
for(int[] item : input) {
    output.add(removeDuplicates(item));
}

So the problem can be reduced to removing duplicates from an int[]. This is solved easily by using a intermediate Set<Integer>, as a Set does not have duplicates by default. Unfortunately, a int[] cannot be put directly into a HashSet<Integer> and vice-versa, so we have to manually copy element-wise:

public int[] removeDuplicates(int[] input) {
    Set<Integer> set = new HashSet<Integer>();
    for (int i = 0; i < input.length; i++)
        set.add(input[i]);
    int[] output = new int[set.size()];
    int i = 0;
    for (Integer e : set) {
        output[i++] = e;
    }
    return output;
}

(See also How to efficiently remove duplicates from an array without using Set)

Everything is much easier of course, if you could have an List<Collection<Integer>> as input and output. In that case, the thing could be done easily as follows:

List<Collection<Integer>> output = new ArrayList<>(input.size());
for(Collection<Integer> item : input) {
    output.add(new HashSet<Integer>(item));
}

Using Java 8 streaming API

For completeness: Java 8 streaming API makes life much easier, even with List<int[]>:

List<int[]> output = input.stream()
    .map(item -> Arrays.stream(item).distinct().toArray())
    .collect(Collectors.toList());

Answer 3

I assume you want to remove duplicates from each array without touching the order.

You can map each array to e.g. LinkedHashSet, which keeps te order but doesn't allow duplicates. Then just map back to int[] and collect using Collectors.toList():

list = list.stream()
    .map(a -> Arrays.stream(a).boxed().collect(Collectors.toList())) // map to List<Integer>
    .map(LinkedHashSet::new) // map to LinkedHashSet<Integer>
    .map(s -> s.stream().mapToInt(i -> i).toArray()) // map to int[]
    .collect(Collectors.toList());