Java 8 lambdas, Function.identity () ou t-> t

Eu tenho uma pergunta sobre o uso do Function.identity()método.

Imagine o seguinte código:

Arrays.asList("a", "b", "c")
          .stream()
          .map(Function.identity()) // <- This,
          .map(str -> str)          // <- is the same as this.
          .collect(Collectors.toMap(
                       Function.identity(), // <-- And this,
                       str -> str));        // <-- is the same as this.

Existe alguma razão para você usar em Function.identity()vez de str->str(ou vice-versa). Eu acho que a segunda opção é mais legível (uma questão de gosto, é claro). Mas, existe alguma razão "real" pela qual alguém deve ser preferido?

Na implementação atual do JRE, Function.identity()sempre retornará a mesma instância, enquanto cada ocorrência de identifier -> identifiernão apenas criará sua própria instância, mas também terá uma classe de implementação distinta. Para mais detalhes, veja aqui .

O motivo é que o compilador gera um método sintético que mantém o corpo trivial dessa expressão lambda (no caso de x->x, equivalente a return identifier;) e informa ao tempo de execução para criar uma implementação da interface funcional que chama esse método. Portanto, o tempo de execução vê apenas métodos de destino diferentes e a implementação atual não analisa os métodos para descobrir se certos métodos são equivalentes.

Portanto, usar em Function.identity()vez de x -> xpode economizar um pouco de memória, mas isso não deve conduzir sua decisão se você realmente acha que x -> xé mais legível do que Function.identity().

Você também pode considerar que, ao compilar com as informações de depuração ativadas, o método sintético terá um atributo de depuração de linha apontando para a (s) linha (s) de código-fonte que contém a expressão lambda, portanto, você poderá encontrar a origem de uma Functioninstância específica durante a depuração . Por outro lado, ao encontrar a instância retornada Function.identity()durante a depuração de uma operação, você não saberá quem chamou esse método e passou a instância para a operação.

No seu exemplo, não há grande diferença entre str -> stre Function.identity()uma vez que internamente é simples t->t.

Mas às vezes não podemos usar Function.identityporque não podemos usar a Function. Dê uma olhada aqui:

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);

isso irá compilar bem

int[] arrayOK = list.stream().mapToInt(i -> i).toArray();

mas se você tentar compilar

int[] arrayProblem = list.stream().mapToInt(Function.identity()).toArray();

você receberá um erro de compilação, pois mapToIntespera ToIntFunction, o que não está relacionado Function. Também ToIntFunctionnão tem identity()método.

Da fonte JDK :

static <T> Function<T, T> identity() {
    return t -> t;
}

Portanto, não, desde que esteja sintaticamente correto.