Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Function.identity(): funzione identità e finisher di un collector

`Function.identity()` fornisce una funzione che restituisce lo stesso riferimento. Come finisher di un collector, restituisce il contenitore di accumulo senza trasformarlo.

Versione: Java SE 21

Sintassi

import java.util.function.Function;

// Static method declaration in java.util.function.Function:
static <T> Function<T, T> identity()

// Typical use:
Function<String, String> same = Function.identity();

Function.identity() è un metodo statico generico dell’interfaccia java.util.function.Function, disponibile da Java 8. La chiamata non accetta argomenti e restituisce una Function<T, T>, con lo stesso tipo di input e di risultato. Il suo apply(x) si comporta come x -> x: restituisce lo stesso riferimento senza copiare o modificare l’oggetto e restituisce null se riceve null.

In Collector<T, A, R>, T è il tipo degli elementi in ingresso, A quello del contenitore di accumulo e R quello del risultato finale. finisher() fornisce una Function<A, R>. Quando A e R sono dello stesso tipo e il contenitore deve diventare il risultato senza modifiche, passa Function.identity() all’overload di Collector.of con finisher esplicito. Se il risultato deve essere una copia o deve essere non modificabile, usa un finisher che esegua quella trasformazione.

Passare Function.identity() come finisher non imposta automaticamente IDENTITY_FINISH. Questa caratteristica consente alla riduzione di omettere la chiamata al finisher. Dichiarala solo se il finisher è una funzione identità e se un cast non verificato da A a R va a buon fine. L’overload di Collector.of senza argomento per il finisher imposta direttamente la caratteristica.

Se un’API richiede un UnaryOperator<T>, usa UnaryOperator.identity(): il comportamento è lo stesso, ma il tipo di ritorno dichiarato è UnaryOperator<T>, non Function<T, T>.

Esempi

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collector;

public class IdentityFinisherDemo {
    public static void main(String[] args) {
        Collector<String, List<String>, List<String>> collector = Collector.of(
                ArrayList::new,
                List::add,
                (left, right) -> {
                    left.addAll(right);
                    return left;
                },
                Function.identity(),
                Collector.Characteristics.IDENTITY_FINISH);

        List<String> input = List.of("Ada", "Lin");
        List<String> buffer = collector.supplier().get();
        input.forEach(name -> collector.accumulator().accept(buffer, name));
        List<String> result = collector.finisher().apply(buffer);

        System.out.println(result == buffer);
        System.out.println(input.stream().collect(collector));
    }
}

Risultato

true
[Ada, Lin]

La prima riga, `true`, mostra che `==` conferma che il riferimento è lo stesso dopo una chiamata diretta al finisher. La seconda, `[Ada, Lin]`, mostra il contenuto raccolto dallo stream, non se lo stream ha invocato il finisher.

Lezioni correlate

  • Java · Lezione 24 · Avanzato · Versione: 2

Fonti