.Min () e .max () do Java 8 stream: por que isso compila?

Nota: esta pergunta se origina de um link morto que era uma pergunta anterior do SO, mas aqui vai ...

Veja este código ( nota: eu sei que esse código não "funcionará" e que Integer::comparedeve ser usado - eu apenas o extraí da pergunta vinculada ):

final ArrayList <Integer> list 
    = IntStream.rangeClosed(1, 20).boxed().collect(Collectors.toList());

System.out.println(list.stream().max(Integer::max).get());
System.out.println(list.stream().min(Integer::min).get());

De acordo com o javadoc de .min()e .max(), o argumento de ambos deve ser a Comparator. No entanto, aqui as referências de método são para métodos estáticos da Integerclasse.

Então, por que isso é compilado?

Deixe-me explicar o que está acontecendo aqui, porque não é óbvio!

Primeiro, Stream.max()aceita uma instância de Comparatorpara que os itens no fluxo possam ser comparados entre si para encontrar o mínimo ou o máximo, em uma ordem ideal com a qual você não precisa se preocupar muito.

Portanto, a questão é, obviamente, por que é Integer::maxaceito? Afinal, não é um comparador!

A resposta está na maneira como a nova funcionalidade lambda funciona no Java 8. Ela se baseia em um conceito que é conhecido informalmente como interfaces de "método abstrato único" ou interfaces "SAM". A idéia é que qualquer interface com um método abstrato possa ser implementada automaticamente por qualquer lambda - ou referência de método - cuja assinatura de método corresponda ao método único na interface. Então, examinando a Comparatorinterface (versão simples):

public Comparator<T> {
    T compare(T o1, T o2);
}

Se um método está procurando por um Comparator<Integer>, então está basicamente procurando por esta assinatura:

int xxx(Integer o1, Integer o2);

Eu uso "xxx" porque o nome do método não é usado para fins de correspondência .

Portanto, ambos Integer.min(int a, int b)e Integer.max(int a, int b)estão próximos o suficiente para que a caixa automática permita que isso apareça como Comparator<Integer>em um contexto de método.

Comparatoré uma interface funcional e Integer::maxestá em conformidade com essa interface (depois de considerar o autoboxing / unboxing). Ele pega dois intvalores e retorna um int- exatamente como você esperaria Comparator<Integer>(novamente, apertando os olhos para ignorar a diferença Inteiro / int).

No entanto, eu não esperaria que ele fizesse a coisa certa, já que Integer.maxisso não está de acordo com a semântica de Comparator.compare. E, de fato, realmente não funciona em geral. Por exemplo, faça uma pequena alteração:

for (int i = 1; i <= 20; i++)
    list.add(-i);

... e agora o maxvalor é -20 e o minvalor é -1.

Em vez disso, as duas chamadas devem usar Integer::compare:

System.out.println(list.stream().max(Integer::compare).get());
System.out.println(list.stream().min(Integer::compare).get());

Isso funciona porque Integer::minresolve uma implementação da Comparator<Integer>interface.

A referência do método Integer::minresolve Integer.min(int a, int b), resolve e IntBinaryOperator, presumivelmente, a autobox ocorre em algum lugar, tornando-o a BinaryOperator<Integer>.

E os min()resp max()métodos da Stream<Integer>pedir a Comparator<Integer>interface a ser implementado.
Agora isso resolve para o método único Integer compareTo(Integer o1, Integer o2). Qual é do tipo BinaryOperator<Integer>.

E assim a mágica aconteceu porque os dois métodos são a BinaryOperator<Integer>.

Além das informações fornecidas por David M. Lloyd, pode-se acrescentar que o mecanismo que permite isso é chamado de digitação de destino .

A idéia é que o tipo que o compilador atribui a expressões lambda ou referências a métodos não depende apenas da expressão em si, mas também de onde é usado.

O destino de uma expressão é a variável à qual seu resultado é atribuído ou o parâmetro ao qual seu resultado é passado.

As expressões lambda e as referências de método recebem um tipo que corresponde ao tipo de seu destino, se esse tipo puder ser encontrado.

Consulte a seção Inferência de tipo no Tutorial Java para obter mais informações.

Eu tive um erro com uma matriz obtendo o máximo e o mínimo, então minha solução foi:

int max = Arrays.stream(arrayWithInts).max().getAsInt();
int min = Arrays.stream(arrayWithInts).min().getAsInt();