Using Java 8 stream methods to get the last max value

Conceptually, you seem to be possibly looking for something like thenComparing using the index of the elements in the list:

Thing t = items.stream() .max(Comparator.comparingLong(Thing::getI).thenComparing(items::indexOf)) .orElse(null); 

To avoid the multiple applications of valueFunction in your reduce solution, simply explicitly calculate the result and put it in a tuple:

Item lastMax = items.stream() .map(item -> new AbstractMap.SimpleEntry<Item, Long>(item, valueFunction.apply(item))) .reduce((l, r) -> l.getValue() > r.getValue() ? l : r ) .map(Map.Entry::getKey) .orElse(null); 

Stream is not necessary bad if you do things in two steps :

1) Find the i value that has more occurrences in the Iterable (as you did)
2) Search the last element for this i value by starting from the end of items:

Thing t = items.stream() .max(Comparator.comparingLong(Thing::getI)) .mapping(firstMaxThing -> return IntStream.rangeClosed(1, items.size()) .mapToObj(i -> items.get(items.size()-i)) .filter(item -> item.getI() == firstMaxThing.getI()) .findFirst().get(); // here get() cannot fail as *max()* returned something. ) .orElse(null) 

The valueFunction now needs to be called nearly twice as often.

Note that even when using max, the getI method will be called again and again for every comparison, not just once per element. In your example, it's called 11 times, including 6 times for D, and for longer lists, too, it seems to be called on average twice per element.

How about you just cache the calculated value directly in the Thing instance? If this is not possible, you could use an external Map and use calculateIfAbsent to calculate the value only once for each Thing and then use your approach using reduce.

Map<Thing, Long> cache = new HashMap<>(); Thing x = items.stream() .reduce((left, right) -> { long leftValue = cache.computeIfAbsent(left, Thing::getI); long rightValue = cache.computeIfAbsent(right, Thing::getI); return leftValue > rightValue ? left : right; }) .orElse(null); 

Or a bit cleaner, calculating all the values beforehand:

Map<Thing, Long> cache = items.stream() .collect(Collectors.toMap(x -> x, Thing::getI)); Thing x = items.stream() .reduce((left, right) -> cache.get(left) > cache.get(right) ? left : right) .orElse(null); 

Here's an implementation of your "roundabout solution" of "Store the object in a Tuple with its computed value" to avoid calculating i more than once per Thing. It's actually fairly straightforward, especially now that Java has record classes:

private static Thing getLastMaxThing(List<Thing> items) { record ThingAndI(Thing thing, long i) { } // Not a musical about a Siamese king return items.stream() .map(t -> new ThingAndI(t, t.getI())) .reduce((t1, t2) -> t1.i() > t2.i() ? t1 : t2) .map(ThingAndI::thing) .orElseThrow(); } 

You can still use the reduction to get this thing done. If t1 is larger, then only it will keep t1. In all the other cases it will keep t2. If either t2 is larger or t1 and t2 are the same, then it will eventually return t2 adhering to your requirement.

Thing t = items.stream(). reduce((t1, t2) -> t1.getI() > t2.getI() ? t1 : t2) .orElse(null); 

Your current implementation using reduce looks good, unless your value-extractor function is costly.

Considering later you may want to reuse the logic for different object types & fields, I would extract the logic itself in separate generic method/methods:

public static <T, K, V> Function<T, Map.Entry<K, V>> toEntry(Function<T, K> keyFunc, Function<T, V> valueFunc){ return t -> new AbstractMap.SimpleEntry<>(keyFunc.apply(t), valueFunc.apply(t)); } public static <ITEM, FIELD extends Comparable<FIELD>> Optional<ITEM> maxBy(Function<ITEM, FIELD> extractor, Collection<ITEM> items) { return items.stream() .map(toEntry(identity(), extractor)) .max(comparing(Map.Entry::getValue)) .map(Map.Entry::getKey); } 

The code snippets above can be used like this:

Thing maxThing = maxBy(Thing::getField, things).orElse(null); AnotherThing maxAnotherThing = maxBy(AnotherThing::getAnotherField, anotherThings).orElse(null); 

One solution would be to do an initial pass of the list to get a maximum value, then do a pass over the list from the end to get the final maximum value. The reversed method added in Java 21 can be used to efficiently stream over the list in reverse.

Thing min = items.stream() .max(Comparator.comparingLong(Thing::getI)) .orElseThrow(); Thing lastMin = items.reversed().stream() .filter(t -> t.getI() == min.getI()) .findFirst() .orElseThrow(); 

At worst, this requires two passes over the list. At best, if a maximum value is near the end of the list, this requires only a little more than a single pass over the list.

If you want to reduce the number of calls to getI (as your comments indicate you want to do):

long maxI = items.stream().mapToLong(Thing::getI).max().orElseThrow(); Thing lastMin = items.reversed().stream() .filter(t -> t.getI() == maxI) .findFirst() .orElseThrow(); 

This implementation calls getI at most twice per object in the list.

One might be tempted to use your initial solution, but reversing the list first:

Thing t = items.reversed().stream() .max(Comparator.comparingLong(Thing::getI)) .orElse(null); 

While this works in practice for current stream implementations, the max method on Stream makes no guarantees as to which element is returned if there's a max, so I personally would advise against relying on it as it could break in different versions of Java.