How to get max() element from List in Guava

Question

Let's say we have a Collection of Items:

class Item {
    public String title;
    public int price;
}

List<Item> list = getListOfItems();

I would like to get an Item with a maximum price out of that list with Guava library (with Ordering, I presume). I mean something similar to this Groovy code:

list.max{it.price}

How do I do that? How efficient is it?

score 59 · Accepted Answer · answered Aug 01 '12 at 12:18

59

Ordering<Item> o = new Ordering<Item>() {
    @Override
    public int compare(Item left, Item right) {
        return Ints.compare(left.price, right.price);
    }
};
return o.max(list);

It's as efficient as it can be: it iterates through the items of the list, and returns the first of the Items having the maximum price: O(n).

answered Aug 01 '12 at 12:18

JB Nizet

678,734
91
1,224
1,255

if price is not int. Are in guava way to use this approach? – gstackoverflow Jan 24 '14 at 09:06
The type of the price is irrelevant. You just need to provide an ordering that compares items by price. Let's say it's BigDecimal, you would use `return left.price.compareTo(right.price)`. – JB Nizet Jan 24 '14 at 09:37

score 38 · Answer 2 · edited Jun 24 '16 at 21:28

38

According to JB's answer, you can also use some shorthand when working with values which have natural order, for example:

Ordering.<Integer> natural().max(listOfIntegers);

See Ordering.natural() for details.

edited Jun 24 '16 at 21:28

Jon

9,156
9
56
73

answered Jan 10 '13 at 12:43

Marcin Kubala

591
6
6

Jeffrey Bosboom · Answer 3 · 2014-09-23T15:59:33.820

You can do this without Guava.

Collections provides min and max methods that operate on any Collection, including overloads taking comparators. Here we use the Java 8 Comparator static methods with a lambda to concisely specify a comparator, but before Java 8 you can use an anonymous class:

Item max = Collections.max(list, Comparator.comparingInt(i -> i.price));

These methods will throw NoSuchElementException if the collection is empty.

Java 8 streams provide min and max functions taking a comparator. These functions return Optional<T> to gracefully handle the stream being empty. The static methods in Comparator are useful for concisely specifying comparators, including the common case of the natural ordering. For this question, you'd use

Optional<Item> max = list.stream().max(Comparator.comparingInt(i -> i.price));

This will work for any stream source, which includes all Collection implementations, as well as other things like files, and makes it easy to compute the max of a subset of a collection by filtering the stream. If you have a large collection and an expensive comparator (e.g., String's natural ordering), you can use a parallel stream.

(Aside: ideally Stream would provide min and max overloads taking no argument when the stream type implements Comparable. Unfortunately Java doesn't support conditionally exposing methods based on a type parameter, and it isn't worth introducing a new StreamOfComparable interface extending Stream just for this case.)

How to get max() element from List in Guava

3 Answers3

Linked