Note able to get Distinct int[] from List

Question

I am trying to get distinct List with unique int[], but I am still getting duplicates.

List<Integer> set1 = Arrays.asList(2, 3, 4, 5, 10, 4, 5, 6, 4);
List<Integer> count = new ArrayList<>();
List<int[]> combination = set1.stream().flatMap(i -> set1.stream().
            flatMap(j -> set1.stream().map(k -> new int[] { i, j, k }))) 
                                      .distinct().collect(Collectors.toList());

My logic to get required elements from the combined list of int[] is the numbers in array should be consecutive with difference of 1.

Ex: {2,3,4}

But in my final list the {2,3,4} is coming 3 times , it is obvious. I want to winnow the occurrences of 3 times {2,3,4} to 1. SO i wrote the below logic. Still there are many elements which are in consecutive form {4,5,6}, i want them also to be only once counted.

 List<int[]> combination1 = combination.stream().distinct().collect(Collectors.toList());
        combination1.stream().filter(i -> Collections.frequency(combination, i) == 1).forEach(s -> {
            if (s[1] - s[0] == 1 && s[2] - s[1] == 1 && s[2] - s[0] == 2) {
                count.add(1);
            } else {
                count.add(0);
            }
        });
        System.out.println(count.stream().mapToInt(Integer::intValue).sum());

I am getting the unique elements as 15, but it should be 3.

My final List<int[]> should contain only : {2,3,4} , {3,4,5} , {4,5,6} and hence count should be three.

score 3 · Accepted Answer · answered Jun 13 '19 at 05:23

Here's the first line of distinct()'s documentation:

Returns a stream consisting of the distinct elements (according to Object.equals(Object)) of this stream.

Now, because you're running it on a Stream<int[]>, int[].equals would have to return true when two int arrays have the same content. But it doesn't (see this). You can solve it by using a list before distinct(), and mapping afterwards (using Integer[] here, but a different mapping is needed for int[]):

List<Integer[]> combination = set1.stream()
    .flatMap(i -> set1.stream()
                      .flatMap(j -> set1.stream().map(k -> Arrays.asList(i, j, k))))
    .distinct()
    .map(l -> l.toArray(new Integer[0]))
    .collect(Collectors.toList());

I got what i wanted. Thank you :) – Joka Lee Jun 13 '19 at 05:34 — Joka Lee, Jun 13 '19 at 05:34

Hadi J · Answer 2 · 2019-06-13T08:22:16.870

Although @ernest_k mention the basic problem for your solution but I think you can do it in simple way.

first create map from set1 elements.

Map<Integer,Integer> map = set1.stream()
                      .collect(Collectors
                                .toMap(Function.identity(),Function.identity(),(v1,v2)->v1));

{2=2, 3=3, 4=4, 5=5, 6=6, 10=10}

then by looping over map values you can create consecutive array.

List<Integer[]> combination = map.values()
            .stream()
            .filter(item -> map.containsKey(item + 1) && map.containsKey(item + 2))
            .map(item -> new Integer[] {item, item + 1, item + 2})
            .collect(Collectors.toList());

As @Holger commented using of set will do simpler.

Set<Integer> set = new HashSet<>(set1);
List<Integer[]> combination = set.stream()
            .filter(item -> set.contains(item + 1) && set.contains(item + 2))
            .map(item -> new Integer[] {item, item + 1, item + 2})
            .collect(Collectors.toList());

Plus one for addressing the OP’s actual task. Note that you don’t need a `Map` here, a `Set` will do as well, which simplifies the whole thing. And well, it can be done [even simpler](https://stackoverflow.com/a/56576092/2711488). And the expression `Arrays.asList(item, item + 1, item + 2).toArray(Integer[]::new)` is a rococo solution for doing a simple `new Integer[] {item, item + 1, item + 2}` — Holger, Jun 13 '19 at 08:14

score 3 · Answer 3 · answered Jun 13 '19 at 08:10

As stated in this answer, int[] arrays do not have the require equality for distinct(). However, IntBuffer can wrap int[] arrays and provide the value based equality. So you can get distinct arrays using the sequence map(IntBuffer::wrap).distinct().map(IntBuffer::array), to wrap the arrays, eliminate duplicates and unwrap the arrays.

However, that problem was part of an entirely unnecessary step, as you weren’t focusing on the actual problem you want to solve.

To get all tuples of consecutive value, you can simply use

List<Integer> set1 = Arrays.asList(2, 3, 4, 5, 10, 4, 5, 6, 4);

int[] ascending = set1.stream().mapToInt(Integer::intValue).sorted().distinct().toArray();

List<int[]> combination = IntStream.rangeClosed(0, ascending.length - 3)
    .mapToObj(ix -> Arrays.copyOfRange(ascending, ix, ix + 3))
    .filter(a -> a[0] + 1 == a[1] && a[1] + 1 == a[2])
    .collect(Collectors.toList());

combination.forEach(a -> System.out.println(Arrays.toString(a)));

Instead of creating 729 combinations of all values, to eliminate redundant combinations, followed by eliminating nonmatching combinations, it generates only the four possible ascending combinations in the first place. Then, it filters these, to accept sequences of consecutive numbers only.

So the last statement will print

[2, 3, 4]
[3, 4, 5]
[4, 5, 6]

Note able to get Distinct int[] from List

3 Answers3