Using Java Streams to operate on an integer power set

Question

I am generating a power set (Set<Set<Integer>>) from an original set (Set<Integer>).

i.e. {1, 2, 3} -> { {}, {1}, {2}, {3}, {1,2}, {2,3}, {1,3}, {1,2,3} }

Then I am using an isClique(Set<Integer>) method that returns a boolean if the given set is a clique in the adjacency matrix I am using.

I want to use a java stream to parallelize this operation and return the largest subset that is also a clique.

I am thinking something like this, but every variation I come up with causes a variety of compilation errors.

Optional result = powerSet.stream().parallel().
    filter(e ->{return(isClique(e));}).
    collect(Collectors.maxBy(Comparator Set<Integer> comparator));

I either get:

MaxClique.java:86: error: incompatible types: Stream<Set<Integer>> cannot be converted to Set<Integer>
    currentMax = powerSet.stream().parallel().filter(e -> { return (isClique(e));});//.collect(Collectors.maxBy(Comparator <Set<Integer>> comparator));

or something related to the comparator (which I'm not sure I'm doing correctly).

Please advise, thanks.

`Comparator Set comparator` - that doesn't seem like valid Java code. — Oliver Charlesworth, Mar 24 '18 at 19:08
This could be a good question but we need more details on what you are trying to achieve, and show for each distinct error message the code that produces it. As it stands now this is unclear and thus off-topic. — Jim Garrison, Mar 24 '18 at 19:09

score 0 · Accepted Answer · answered Mar 24 '18 at 19:16

0

You have some syntax problems. But beside that, you can compute the same optional using:

Optional<Set<Integer>> result = powerSet.stream().parallel()
    .filter(e -> isClique(e))
    .collect(
       Collectors.maxBy(
           (set1, set2) -> Integer.compare(set1.size(), set2.size())
       )
    );

This is filtering based on your condition, then pulling the max value based on a comparator that compares set sizes.

answered Mar 24 '18 at 19:16

ernest_k

44,416
5
53
99

you can simplify the `(set1, set2) -> Integer.compare(set1.size(), set2.size())` to `Comparator.comparing(Set::size)` or better `Comparator.comparingInt(Set::size)`. – Ousmane D. Mar 24 '18 at 19:41
@Aominè How cool... Didn't think of that. Thanks for the tip! – ernest_k Mar 24 '18 at 19:46
Thank you! This worked like a charm! Also thanks @Aominè, neat trick! – Chris Schertenlieb Mar 24 '18 at 20:53

Ousmane D. · Answer 2 · 2018-03-24T19:53:06.320

Your major issue is using the wrong syntax for the comparator. Rather, you'd want something along the lines of:

Optional<Set<Integer>> resultSet = 
                    powerSet.stream()
                            .parallel()
                            .filter(e -> isClique(e))
                            .max(Comparator.comparingInt(Set::size));

Note the use of the max method as opposed to the maxBy, this is because the maxBy is typically used as a downstream collector. in fact, the real motivation for it to exist is to be used as a downstream collector.

Also, note the use of Optional<Set<Integer>> being the receiver type as opposed to Optional as in your example code snippet. The latter is a raw type and you should avoid to use them unless there is no choice.

Lastly, but not least, if you haven't already done so then I'd suggest you try executing the code sequentially first and if you think you can benefit from parallel streams then you can proceed with the current approach.

Using Java Streams to operate on an integer power set

2 Answers2