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

Ho una domanda sull'uso del Function.identity()metodo.

Immagina il seguente codice:

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.

C'è qualche motivo per cui dovresti usare Function.identity()invece di str->str(o viceversa). Penso che la seconda opzione sia più leggibile (una questione di gusti ovviamente). Ma c'è qualche motivo "reale" per cui uno dovrebbe essere preferito?

A partire dall'attuale implementazione JRE, Function.identity()restituirà sempre la stessa istanza mentre ogni occorrenza di identifier -> identifiernon solo creerà la propria istanza ma avrà anche una classe di implementazione distinta. Per maggiori dettagli, vedi qui .

Il motivo è che il compilatore genera un metodo sintetico che contiene il corpo banale di quell'espressione lambda (nel caso di x->x, equivalente a return identifier;) e dice al runtime di creare un'implementazione dell'interfaccia funzionale che chiama questo metodo. Quindi il runtime vede solo diversi metodi target e l'implementazione corrente non analizza i metodi per scoprire se determinati metodi sono equivalenti.

Quindi usare al Function.identity()posto di x -> xpotrebbe risparmiare un po 'di memoria, ma ciò non dovrebbe guidare la tua decisione se pensi davvero che x -> xsia più leggibile di Function.identity().

Puoi anche considerare che durante la compilazione con le informazioni di debug abilitate, il metodo sintetico avrà un attributo di debug di linea che punta alle righe del codice sorgente che contengono l'espressione lambda, quindi hai la possibilità di trovare l'origine di una particolare Functionistanza durante il debug . Al contrario, quando si incontra l'istanza restituita Function.identity()durante il debug di un'operazione, non si saprà chi ha chiamato quel metodo e ha passato l'istanza all'operazione.

Nel tuo esempio non c'è grande differenza tra str -> stre Function.identity()poiché internamente lo è semplicemente t->t.

Ma a volte non possiamo usare Function.identityperché non possiamo usare a Function. Dai un'occhiata qui:

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

questo compilerà bene

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

ma se provi a compilare

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

si otterrà errore di compilazione in quanto mapToIntsi aspetta ToIntFunction, che non è legato al Function. Inoltre ToIntFunctionnon ha identity()metodo.

Dalla fonte JDK :

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

Quindi no, purché sia ​​sintatticamente corretto.