Java列表：使用lambda表达式获取成对的具有成对的不同键的对

Question

I have a list of key-value-pairs and I want to filter a list where every key parameter only occurs once.

So that a list of eg {Pair(1,2), Pair(1,4), Pair(2,2)} becomes {Pair(1,2), Pair(2,2)} .

It doesn't matter which Pair gets filtered out as I only need the size (maybe there's a different way to get the amount of pairs with pairwise different key values?).

This all is again happening in another stream of an array of lists (of key-value-pairs) and they're all added up.

I basically want the amount of collisions in a hashmap.

I hope you understand what I mean; if not please ask.

public int collisions() {
    return Stream.of(t)
            .filter(l -> l.size() > 1)
            .filter(/*Convert l to list of Pairs with pairwise different Keys*/)
            .mapToInt(l -> l.size() - 1)
            .sum();
}

EDIT:

    public int collisions() {
    return Stream.of(t)
            .forEach(currentList = stream().distinct().collect(Collectors.toList())) //Compiler Error, how do I do this?
            .filter(l -> l.size() > 1)
            .mapToInt(l -> l.size() - 1)
            .sum();
}

I overwrote the equals of Pair to return true if the Keys are identical so now i can use distinct to remove "duplicates" (Pairs with equal Keys). Is it possible to, in forEach, replace the currentElement with the same List "distincted"? If so, how?

Regards, Claas M

Answer 1

Don't use a stream. Dump the list into a SortedSet with a custom comparator and diff the sizes:

List<Pair<K, V>> list; // given this

Set<Pair<K, V>> set = new TreeSet<>(list, (a, b) -> a.getKey().compareTo(b.getKey())).size();
set.addAll(list);
int collisions = list.size() - set.size();

If the key type isn't comparable, alter the comparator lambda accordingly.

Answer 2

I'm not sure whether you want the sum of amount of collisions per list or the amount of collisions in all list were merged into a single one before. I assumed the former, but if it's the latter the idea does not change by much.

This how you could do it with Streams :

int collisions = Stream.of(lists)
                       .flatMap(List::stream)
                       .mapToInt(l -> l.size() - (int) l.stream().map(p -> p.k).distinct().count())
                       .sum();

Stream.of(lists) will give you a Stream<List<List<Pair<Integer, Integer>> with a single element. Then you flatMap it, so that you have a Stream<List<Pair<Integer, Integer>> .

From there, you mapToInt each list by substracting its original size with the number of elements of unique Pairs by key it contained ( l.stream().map(p -> pk).distinct().count() ).

Finally, you call sum to have the overall amount of collisions.

Note that you could use mapToLong to get rid of the cast but then collisions has to be a long (which is maybe more correct if each list has a lot of "collisions").

For example given the input:

List<Pair<Integer, Integer>> l1 = Arrays.asList(new Pair<>(1,2), new Pair<>(1,4), new Pair<>(2,2));
List<Pair<Integer, Integer>> l2 = Arrays.asList(new Pair<>(2,2), new Pair<>(1,4), new Pair<>(2,2));
List<Pair<Integer, Integer>> l3 = Arrays.asList(new Pair<>(3,2), new Pair<>(3,4), new Pair<>(3,2));

List<List<Pair<Integer, Integer>>> lists = Arrays.asList(l1, l2, l3);

It will output 4 as you have 1 collision in the first list, 1 in the second and 2 in the third.