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

J'ai une question concernant l'utilisation de la Function.identity()méthode.

Imaginez le code suivant:

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.

Y a-t-il une raison pour laquelle vous devriez utiliser à la Function.identity()place de str->str(ou vice versa). Je pense que la deuxième option est plus lisible (une question de goût bien sûr). Mais, y a-t-il une «vraie» raison pour laquelle on devrait être préféré?

À partir de l'implémentation JRE actuelle, Function.identity()retournera toujours la même instance tandis que chaque occurrence de identifier -> identifiercréera non seulement sa propre instance mais aura même une classe d'implémentation distincte. Pour plus de détails, voir ici .

La raison en est que le compilateur génère une méthode synthétique contenant le corps trivial de cette expression lambda (dans le cas de x->x, équivalent à return identifier;) et indique au runtime de créer une implémentation de l'interface fonctionnelle appelant cette méthode. Le runtime ne voit donc que différentes méthodes cibles et l'implémentation actuelle n'analyse pas les méthodes pour savoir si certaines méthodes sont équivalentes.

Donc, utiliser Function.identity()au lieu de x -> xpourrait économiser de la mémoire, mais cela ne devrait pas motiver votre décision si vous pensez vraiment que c'est x -> xplus lisible que Function.identity().

Vous pouvez également considérer que lors de la compilation avec les informations de débogage activées, la méthode synthétique aura un attribut de débogage de ligne pointant vers la ou les lignes de code source contenant l'expression lambda, vous avez donc une chance de trouver la source d'une Functioninstance particulière lors du débogage . En revanche, lorsque vous rencontrez l'instance retournée par Function.identity()lors du débogage d'une opération, vous ne saurez pas qui a appelé cette méthode et transmis l'instance à l'opération.

Dans votre exemple, il n'y a pas de grande différence entre str -> stret Function.identity()puisque c'est en interne simplement t->t.

Mais parfois, nous ne pouvons pas utiliser Function.identityparce que nous ne pouvons pas utiliser un Function. Jetez un œil ici:

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

cela compilera bien

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

mais si vous essayez de compiler

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

vous obtiendrez une erreur de compilation depuis mapToIntattend ToIntFunction, ce qui n'est pas lié à Function. N'a ToIntFunctionpas non plus de identity()méthode.

De la source JDK :

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

Donc, non, tant qu'il est syntaxiquement correct.