Get the two min objects from a set using Java stream

Question

I have a Set of some objects. I need to get the two min objects from the Set.

My example is as follows:

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Example {
     public static void main( String[] args ) {
         SomeObject obj1 = new SomeObject(1);
         SomeObject obj2 = new SomeObject(2);
         SomeObject obj3 = new SomeObject(3);
         Set<SomeObject> set = Stream.of(obj1,obj2,obj3)
                                     .collect(Collectors.toSet());

         SomeObject minObject= set.stream()
                                  .min(Comparator.comparingInt(object->object.getValue()))
                                  .get();
         System.out.println(minObject);
     }
}


class SomeObject{
    private int value;
    SomeObject(int value){
            this.value=value;
    }

    public int getValue() {
        return value;
    }

    @Override
    public String toString() {
        return this.value+"";
    }
}

In my example I can get the min object from this Set based on the value attribute.

So, I need to get the two min values using Java stream operations.

The answers should be fast because in my real program I call this method many times and my sets are very large.

Answer 1

You can get the second min value as follows:

 set.stream()
    .filter(s -> s.getValue() != minObject.getValue())     
    .min(Comparator.comparingInt(object -> object.getValue()))
    .get();

• This streams over the set of elements again ensuring that we're ignoring the previous min value via filter.
• Then we get the min value via min

or you can get both at the same time:

Stream<SomeObject> twoMinValues = set.stream()
                   .sorted(Comparator.comparingInt(object -> object.getValue()))
                   .limit(2);

• This streams over the set of elements, sorting the entire sequence from smallest to largest and then taking the first two which is definitely less efficient than the above approach due to the behaviour of the "sorted" intermediate operation.

The awnser should be fast because In my real program i call this method many times and my Sets are very Large.

As for needing a "fast" program, I'd recommend that you first try to solve the problem at hand just using the typical imperative approach as in most cases they're faster than using streams.

if it's not much better then "consider" using parallel streams if and only if you know that you can leverage parallelism.

see Should I always use a parallel stream when possible?

Answer 2

You can pass your Set<E> to an instance of NavigableSet<E>, then you can poll the first two (lowest) elements from it :

final NavigableSet<SomeObject> navigableSet = new TreeSet<>(Comparator.comparingInt(SomeObject::getValue));

navigableSet.addAll(set);

final SomeObject firstMin = navigableSet.pollFirst();

final SomeObject secondMin = navigableSet.pollFirst();