Stream.max(Integer::max) : Unexpected result [duplicate]

Answer 1

Integer.max(a, b) will return the greater value of the given a and b. If you use that result somehow as a comparator, a positive value returned will be regarded as meaning that a > b so a will be kept.

The first two elements are 3 and 4. Both are positive. Integer.max(3, 4) = 4 > 0. So you're effectively saying that 3 > 4 with such a comparator, so 3 is kept. Then, the same goes for the rest: Integer.max(3, 6) = 6 > 0, so 3 is considered the max, etc.

Answer 2

This is unbelievably confusing.

We are trying use Integer::max as a comparator. Since all the numbers in the question are positive, the answer is always interpreted as meaning that the first argument of compare(a, b) is "greater" than the second.

One quirk of Collections.sort is that when you have a list [a, b], the method is programmed in such a way that it is compare(b, a) that is called, rather than compare(a, b) (which would seem more sensible). Hence if compare returns a positive number, it looks like b > a, so the list does not need sorting.

That is why list.sort does nothing.

However it just happens that Stream.max is programmed the other way around, i.e. the first comparison is compare(3, 4), so it looks like 3 is the maximum.

Answer 3

Although this doesn't answer the question, a possible solution to your problem would be:

try{
    int i = map.values().stream().mapToInt(e -> e).max().getAsInt();
}catch(NoSuchElementException e)
    e.printStackTrace();
}

The mapToInt(e -> e) method uses a lambda expression to transform every element in the stream to a integer value and returns a IntStream where max() method can then be called. Note that max() returns an OptionalInteger and so a getAsInt() or a orElse(0) method call is nedeed.

You can take a look at the docs for a more in-depth answer: IntStream, OptionalInt

Answer 4

You need to replace

.max(Integer::max)

with

.max(Integer::compare)

---

The problem here is that the abstract method compare is declared to return an int value and that is also satisfied by the signature of Integer.max along with method Integer.compare in the Integer class, hence the representation Integer::max is inferred as a valid Comparator. Though the compare method is expected to be implemented such as it:

Returns a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.

In your current scenario, the code always ends up returning a positive value (given the input) and therefore the first element in comparison is considered to be greater always and thus returned accordingly.

Answer 5

The contract of a comparator method (on arguments first, second) is:

• return 0 if first equals second
• return negative value if first < second
• return positive value if first > second

The max method with only positive values will always return a positive value. When interpreting the return value according to the comparator contract, a positive value means first > second. As a result, the ordering of items will not change, they appear to be "ordered".