Using Streams to find max value of a List of Objects

[Sot Nikele]

Hallo again, I find it difficult to accomplish this task as a noob with Streams.

Having a list of Items, each item has a value and a name. Using Streams, how can I get the item or items with the max value?

And another question, again using Streams, how can I remove those items having the max value?

Thanks in advance.

[Campbell Ritchie]

Adding you to our Streams forum.

Whatever you are doing, if you want a maximum value, you need some way to compare those values to decide whether,

value1 is “greater than” value2, or

value1 is “less than” value2, or

value1 is “the same as” value2.

I suggest you go through the Collections part of the Java™ Tutorials, particularly looking at the section called, “Object Ordering”. Then come back when you have understood that section and decided how to order any two of your objects.

Do your objects have a “natural ordering”? That means that every two objects fulfil the three bullet points above, and that if you don't change anything you get the same results, and there is one single criterion used for the ordering. Some kinds of object have multiple possible orderings.

[Campbell Ritchie]

Have you been through the methods of the Stream interface? I think you will find something useful if you go through the names of all the methods.

[Paul Clapham]

Sot Nikele wrote:And another question, again using Streams, how can I remove those items having the max value?

Streams aren't generally meant to modify the object from which they are streaming their data. Instead of trying to fight against that principle, I would say you are better off producing a new List<Item> which contains only those items which don't have the max value.

This would require one Stream which produces the max value, and then a second Stream which filters objects which don't have the max value into that new list.

[Himai Minh]

Sot,
You may consider using stream's max and Comparator:
https://www.baeldung.com/java-collection-min-max

[Mehmet Anıl Çorapcı]

I know you said you start stream and i don't wanna scare you but you can do it like this.
I use parallelStream() instead of stream() because i wanna trigger *1 for myself. (*1 is new to me)

import java.util.ArrayList;
import java.util.List;

public class StreamApiCollectExample {
    public static void main(String[] args) {
        var list = List.of(new AwesomeObject().name("AAA").value(10),
                new AwesomeObject().name("BBB").value(20),
                new AwesomeObject().name("CCC").value(20),
                new AwesomeObject().name("CCC").value(30),
                new AwesomeObject().name("DDD").value(30),
                new AwesomeObject().name("EEE").value(20),
                new AwesomeObject().name("FFF").value(30));

        var map = list.parallelStream()
                .collect(() -> new ArrayList<AwesomeObject>(),
                        (ArrayList<AwesomeObject> tempResultList, AwesomeObject tempAwesome) -> {
                            if (tempResultList.isEmpty() || tempResultList.get(0).getValue() == tempAwesome.getValue()) {
                                tempResultList.add(tempAwesome);
                                return;
                            }

                            if (tempResultList.get(0).getValue() < tempAwesome.getValue()) {
                                tempResultList.clear();
                                tempResultList.add(tempAwesome);
                            }
                        },
                        (ArrayList<AwesomeObject> oldList, ArrayList<AwesomeObject> newList) -> { // *1
                            if (newList.isEmpty()) {
                                return;
                            }

                            if (oldList.isEmpty() || oldList.get(0).getValue() < newList.get(0).getValue()) {
                                oldList.clear();
                                oldList.addAll(newList);
                                return;
                            }

                            if (oldList.get(0).getValue() == newList.get(0).getValue()) {
                                oldList.addAll(newList);
                            }
                        });

        System.out.println(map);
    }
}

class AwesomeObject {
    private int value;
    private String name;

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public AwesomeObject value(int value) {
        this.value = value;
        return this;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public AwesomeObject name(String name) {
        this.name = name;
        return this;
    }

    @Override
    public String toString() {
        return "AwesomeObject{" +
                "value=" + value +
                ", name='" + name + '\'' +
                '}';
    }
}

[Campbell Ritchie]

Welcome to the Ranch

That code looks surprisingly complicated; there must ba an easier way to do it.

[Piet Souris]

hi Mehmet,

as Campbell writes, thre are easier ways to achieve the result, but I surely like your method.

You could make the code a little more readable by creating two BiConsumers:

BiConsumer<List<AwesomeObject>, AwesomeObject> bic = ...;

and

BiConsumer<List<AwesomeObject>, List<AwesomeObject>> bicList {...}

and use these in your '.collect'.

Another way to shorten your code is to have

record Mehmet(String name, int value){}   // java 16, instead of your long AwesomeObject class

I used your idea, but instead of creating an ArrayList with the maximum objects, I created a TreeMap<Integer, List<Object>>, so that that map's lastEntry gives us the max objects.
For that I created a record and a helper class to keep the typing to a minimum:

record Mehmet(String name, int value) {}
class Short extends TreeMap<Integer, List<Mehmet>> {}

Using the 3-parameter version of collect, I needed, as you did, to write a BiConsumer<Short, Mehmet>, and a BiConsumer<Short, Short>. Since
you are using a parallelStream, that last one was a little nasty.
Well, I hope you find this instructive:

public class MehmetAnilCorapci {
    public static void main(String... args) {
        Supplier<Short> sup = Short::new; 
        BiConsumer<Short, Mehmet> bicm = (s, m) -> 
            s.computeIfAbsent(m.value(), k -> new ArrayList<>()).add(m);
        BiConsumer<Short, Short> bics = (s1, s2) -> 
            s2.entrySet().forEach(e -> 
                s1.merge(e.getKey(), e.getValue(), (a, b) -> {a.addAll(b); return a;}))
        ;
        var list = List.of(new Mehmet("BBB", 20),
                           new Mehmet("CCC", 20),
                           new Mehmet("CCC", 30),
                           new Mehmet("DDD", 30),
                           new Mehmet("EEE", 20),
                           new Mehmet("FFF", 30)
        );
        var result = list.parallelStream().collect(sup::get, bicm, bics);
        result.forEach((k, v) -> System.out.format("%d: %s%n", k, v));
        System.out.println(result.lastEntry().getValue());
    }
}

record Mehmet(String name, int value) {}
class Short extends TreeMap<Integer, List<Mehmet>> {}

And have a cow for your code!

[Stephan van Hulst]

I find your code extremely confusing Piet. Please don't use existing type names for custom types. The name Short to me means java.lang.Short, which is the primitive wrapper type for the short integral type. It took me a while to realize it was a kind of type alias for a Map instead.

I'm also not a fan of declaring variables to hold functional types. Instead, just write a private method instead of a lambda expression and use a method reference.

Don't use method references or lambdas to refer to a method of a functional type. Pass the function object directly. In your code, you use sup::get in collect(), while passing sup directly will suffice.

Note that your collection operation can be replaced by just the following:

var result = list.parallelStream().collect(
  groupingBy(
    Mehmet::value,
    TreeMap::new,
    toList()
  )
);

Or, if you want improved performance at the cost of losing encounter order:

var result = list.parallelStream().collect(
  groupingByConcurrent(
    Mehmet::value,
    ConcurrentSkipListMap::new,
    toList()
  )
);

The second option still maintains correct ordering of the keys, so you can still use lastEntry() to get the list of maximum elements, the list itself just won't maintain encounter order.

Now, if I didn't have access to the groupingBy() collector, I would write the code like this:

  static <T, K extends Comparable<? super K>>
  Collector<T, ?, NavigableMap<K, Collection<T>>> groupingByComparableKey(
    Function<? super T, ? extends K> classifier
  ) {
    final class Accumulation {

      private final NavigableMap<K, Collection<T>> map = new TreeMap<>();

      void accumulate(T element) {
        var key = classifier.apply(element);
        map.computeIfAbsent(key, absent -> new ArrayList<>()).add(element);
      }

      Accumulation combine(Accumulation other) {
        other.map.forEach((key, collection) -> {
          this.map.merge(key, collection, (thisCollection, otherCollection) -> {
            thisCollection.addAll(otherCollection);
            return thisCollection;
          });
        });

        return this;
      }

      NavigableMap<K, Collection<T>> finish() {
        return map;
      }
    }

    return Collector.of(
      Accumulation::new,
      Accumulation::accumulate,
      Accumulation::combine,
      Accumulation::finish
    );
  }

As you can see, the accumulate() and combine() methods closely resemble your consumers, except I made them into methods on a local Accumulation class.

This collector can easily be used in your main method and gives the exact same results as your original code:

  public static void main(String... args) {
    var list = List.of(new Mehmet("BBB", 20),
      new Mehmet("CCC", 20),
      new Mehmet("CCC", 30),
      new Mehmet("DDD", 30),
      new Mehmet("EEE", 20),
      new Mehmet("FFF", 30)
    );

    var result = list.parallelStream().collect(groupingByComparableKey(Mehmet::value));

    result.forEach((k, v) -> System.out.format("%d: %s%n", k, v));

    System.out.println(result.lastEntry().getValue());
  }

[Piet Souris]

Well, if YOU say it's confusing,  then I guess it must be.

As you can see, I did use the groupingBy in an earlier example, but here I followed OP's way with the .collect(supplier...), involving two BiConsumers.

And I like using variables for functional interfaces, makes the code much more readable. You are right about my Short; can't remember ever having used a Short, I guess I forgot its existance. But the name 'Short'  instead of ' TreeMap<integer, List<Mehmet>> seemed very reasonable.

But as said, point was to use the 3-parameter version of collect, something that you don't see too often.

[Stephan van Hulst]

I will admit that most of it comes down to personal preference. The only serious gripe I had was the Short thing.

If you want to use a type alias instead of writing down a long type name multiple times, consider using a generic helper method:

private static <M extends TreeMap<Integer, List<Mehmet>>> void main(Supplier<? extends M> sup) {
  // basically the exact same code as your main method,
  // except you use M instead of Short.
}

public static void main(String... args) {
  main(TreeMap::new);
}

This avoids declaring an empty class.

[Mehmet Anıl Çorapcı]

Hi Piet,
First of all thanks for giving your class to my name I was too focus to collect list and you showed me TreeMap is better option. I loved your result.lastEntry() trick <3  I agree Stephan's mentions about your helper class naming conventions. Also i think your helper class is confusing, i want to see TreeMap<Integer, List<Mehmet>>  instead of another class. I was tought writing lambda expressions in method's param's  is better but my lambda goes for too long. I am on your side now

Hi Stephan,
Your suggestions cool about Piet's helper class naming conventions. Accumulation class seems complicated to me but i will give a shot when i need to declare lamda more than one.

[Rurik Janiszewski]

Hi Piet,

I am new here but I know a web site that you can be helped a lot with this subject and other ones.
Using stream and reduce will be much easier.

web site -> https://www.techiedelight.com/find-maximum-minimum-custom-objects-java/#:~:text=1.,maximum%20object%20in%20the%20stream

[Campbell Ritchie]

Welcome to the Ranch

That looks a good website.
But the hard part is defining what more than or less than; once you have that, the Streams interface can find the maximum and minimum very easily.