Java 8 streams: determining if members of a list are "equal"

Question

I am trying to make a very concise way (using streams, of course) to determine if two members of a collection (a list) are equal. But not equal in the sense of the method equals() but using a different method for comparing.

Basically, I have a list of timeslots, and these define an order. You can say if a timeslot precedes, passes or is equal to another using the Timeslot#compareTo(Timeslot) method. I need these timeslots to be in order, that is, every one of them precedes the following in the list, but I also need each one of them to be strictly greater than the next one. They cannot be equal (you cannot have timeslot1=10am and then timeslot2=10am).

I got the ordering covered, as easy as this:

Collections.sort(timeslots, Timeslot::compareTo);

However, I would like to be very concise when determining if every timeslot strictly precedes the following or not. Of course, I could do this the traditional way as follows:

for (int i = 0; i < timeslots.size() - 1; i++)
    if (timeslots.get(i).compareTo(timeslots.get(i + 1)) == 0)
        throw new IllegalArgumentException("Every timeslot must strictly precede the following");

Maybe I am asking too much of streams, and there is really no better and equally efficient way of achieving this, but I would be glad to hear out your ideas.

Answer 1

Maybe you are thinking too complicated by trying to find a Stream API solution. The task can be easily solved using basic Collection API operations:

List<Timeslot> timeslots;// the source

TreeSet<Timeslot> sorted=new TreeSet<>(timeslots);
if(sorted.size() != timeslots.size())
  throw new IllegalArgumentException("Every timeslot must strictly precede the following");
// get a list where every timeslot strictly precedes the following:
timeslots=new ArrayList<>(sorted);

The equality of the TreeSet’s elements is only determined by the order. So if there are duplicates according to the order, and this is what your problem is all about, they are removed when converting the list to the set. So if the size differs, there were such duplicates. If not, you can convert the sorted set back to a list, if you need a list. Otherwise, you can just continue using the set instead of the list.

---

It should be mentioned, since you stated to have a ordering which is not consistent with equals, that the TreeSet will also not be fully compliant with the Set contract as stated in its documentation:

Note that the ordering maintained by a set (whether or not an explicit comparator is provided) must be consistent with equals if it is to correctly implement the Set interface. […] This is so because the Set interface is defined in terms of the equals operation, but a TreeSet instance performs all element comparisons using its compareTo (or compare) method, so two elements that are deemed equal by this method are, from the standpoint of the set, equal. The behavior of a set is well-defined even if its ordering is inconsistent with equals; it just fails to obey the general contract of the Set interface.

Since your operation does not rely on the general contract of the Set interface, as there was no Set before, this is not a problem for this specific use case. Converting to a List as shown above works and so would iterating over the elements, in case you use it without conversion, i.e. don’t need specific list operations.

Answer 2

I think sorting the list and comparing adjacent elements is a reasonable approach. Here's the streams-based code that does that:

    timeslots.sort(null);  // sort the list using natural order
    if (IntStream.range(1, timeslots.size())
                 .map(i -> timeslots.get(i-1).compareTo(timeslots.get(i)))
                 .anyMatch(i -> i == 0)) {
        throw new IllegalArgumentException("...");
    }

It's no shorter than what you have, but the streams-based approach might offer more flexibility: it can be run in parallel, you can count the number of duplicate timestamps, etc.

You could also inline the compareTo() call into the anyMatch() call, like so:

    if (IntStream.range(1, timeslots.size())
                 .anyMatch(i -> timeslots.get(i-1).compareTo(timeslots.get(i)) == 0) {

Whether this is preferable is, I think, a matter of style.

Answer 3

Simple — Just use Stream 'sorted' and make custom comparator.

See https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html#sorted-java.util.Comparator-

Something like this:

Timeslots timeslots = ... 

Stream<Timeslots> tstream  = timeslots
     .stream()
     .sorted( (a,b) -> {
          int compare = a.compareTo(b);
          if(compare==0){
               throw new IllegalArgumentException("Every timeslot must strictly precede the following");
          }
          return compare;
     });

And yes ... you need a terminal operation for the Stream to actually run. I assume that there is a next operation or something you feed the Timeslots to.

With this method you get a Stream result and there is no need to pre-sort the Timeslots beforehand.

Give it a try!

Answer 4

I'm not sure this is much more concise than your version, but here's how you could do it with streams:

timeslots.stream().reduce((a, b) -> {
    if (a.compareTo(b) == 0) {
        throw new IllegalArgumentException("Every timeslot must strictly precede the following");
    }
    return b;
});

Another solution, inspired by @VGR's comment:

timeslots.stream().collect(Collectors.toMap(Function.identity(), Function.identity(), (a, b) -> {
    throw new IllegalArgumentException("Every timeslot must strictly precede the following");
}, () -> new TreeMap<>(Timeslot::compareTo)));