Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

Function.identity(): função identidade e finalizador de um coletor

`Function.identity()` fornece uma função que devolve a mesma referência. Como finalizador de um coletor, devolve o contentor de acumulação sem o transformar.

Versão: Java SE 21

Sintaxe

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() é um método genérico estático da interface java.util.function.Function, disponível desde o Java 8. A chamada não recebe argumentos e devolve uma Function<T, T>, com o mesmo tipo de entrada e de resultado. O seu apply(x) comporta-se como x -> x: devolve a mesma referência sem copiar nem alterar o objeto e devolve null quando recebe null.

Em Collector<T, A, R>, T é o tipo dos elementos de entrada, A o do contentor de acumulação e R o do resultado final. finisher() fornece uma Function<A, R>. Quando A e R são do mesmo tipo e o contentor deve ser devolvido sem alterações, passa Function.identity() à sobrecarga de Collector.of com finalizador explícito. Se o resultado tiver de ser uma cópia ou não puder ser modificável, utiliza um finalizador que faça essa transformação.

Passar Function.identity() como finalizador não define automaticamente IDENTITY_FINISH. Esta característica permite que a redução omita a chamada ao finalizador. Declara-a apenas se o finalizador for uma função identidade e se uma conversão de tipo não verificada de A para R for bem-sucedida. A sobrecarga de Collector.of sem o argumento do finalizador define a característica por si só.

Se uma API exigir um UnaryOperator<T>, utiliza UnaryOperator.identity(): o comportamento é o mesmo, mas o tipo de retorno declarado é UnaryOperator<T>, não Function<T, T>.

Exemplos

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));
    }
}

Resultado

true
[Ada, Lin]

A primeira linha, `true`, mostra que `==` confirma que a referência é a mesma após uma chamada direta ao finalizador. A segunda, `[Ada, Lin]`, mostra o conteúdo recolhido do fluxo, não se o fluxo chamou o finalizador.

Lições relacionadas

  • Java · Lição 24 · Avançado · Versão: 2

Fontes