Genéricos, expressões lambda e fluxos de elementos em Java

Um contêiner deve informar o que armazena. Com um parâmetro de tipo, uma classe pode armazenar cadeias de caracteres, números ou seus próprios objetos, e o compilador verifica cada uso antes de o programa ser executado.

Dê um parâmetro de tipo a uma classe

Em class Box<T>, T é um parâmetro de tipo: um nome para um tipo que será fornecido por quem usa a classe. Use-o em campos, parâmetros de métodos e resultados.

class Box<T> {
    private T value;

    public Box(T value) { this.value = value; }
    public T get() { return value; }
    public void set(T value) { this.value = value; }
}

O nome do construtor é Box, sem <T>. A declaração após o nome da classe introduz T para o corpo da classe. Agora crie uma caixa:

Box<String> b = new Box<>("tea");
String drink = b.get();
b.set("water");
System.out.println(drink);   // tea
System.out.println(b.get()); // water

String é o argumento de tipo. Para essa variável, get() retorna uma String, e set aceita uma String. Não há conversão explícita na leitura. A tentativa de chamar b.set(42) falha na compilação: “incompatible types: int cannot be converted to String”. O erro aponta a gravação incorreta antes que uma leitura posterior possa falhar.

Por que não armazenar Object?

Um campo Object pode referenciar uma cadeia de caracteres ou um inteiro. O código que precisa de uma cadeia de caracteres deve converter explicitamente o objeto retornado. Se um inteiro tiver sido armazenado, essa conversão lança ClassCastException durante a execução do programa. Uma Box<String> torna a relação desejada parte do tipo declarado.

O operador diamante <> em new Box<>("tea") solicita que o compilador infira os argumentos de tipo. Ele mantém as verificações. Omitir completamente os sinais de menor e maior, como em new Box("tea"), usa um tipo bruto e perde as verificações relacionadas ao parâmetro de tipo. Atribuir uma construção bruta a uma variável tipada produz avisos de operação não verificada; a variável tipada ainda impõe seu próprio argumento declarado nas chamadas posteriores.

Use classes empacotadoras e vários parâmetros

Um argumento de tipo deve ser um tipo de referência. Use Box<Integer>, não Box<int>. Java empacota o literal 5 como um Integer ao construir new Box<Integer>(5) e o desempacota quando uma operação aritmética precisa de um int. Se n contém essa caixa, int next = n.get() + 1; fornece 6.

Dois tipos independentes precisam de dois parâmetros. Uma Pair<K, V> pode ter um campo K first e um campo V second. Para uma Pair<String, Integer>, seus métodos de acesso retornam uma String e um Integer. Nomes comuns são T para tipo, E para elemento, K e V para chave e valor e R para resultado.

Coloque parâmetros de tipo em interfaces

interface Container<T> {
    void put(T item);
    T take();
}

Uma classe pode preservar a escolha com class Shelf<T> implements Container<T> ou fixá-la com class NameList implements Container<String>. List<E> e Comparable<T> usam a mesma ideia. Uma classe genérica continua sendo uma única classe: Box<String> e Box<Integer> descrevem usos com verificações de compilação diferentes, não duas declarações de classe. Elas não podem ser atribuídas uma à outra porque especificam tipos de elemento diferentes.

Algumas operações precisam de uma escolha de tipo para uma chamada, não para o tempo de vida de um objeto. Um método genérico introduz seu próprio parâmetro de tipo e mantém uma relação entre sua entrada e seu resultado.

Declare o tipo antes do tipo de retorno

import java.util.List;

class Lists {
    public static <T> T last(List<T> list) {
        return list.get(list.size() - 1);
    }

    public static void main(String[] args) {
        int number = last(List.of(4, 8, 15));
        String word = Lists.<String>last(List.of("x", "y"));
        System.out.println(number); // 15
        System.out.println(word);   // y
    }
}

Leia a declaração por partes. static faz dele um método de classe. <T> introduz um parâmetro de tipo pertencente ao método. O T seguinte é o tipo de retorno. List<T> indica que a lista de entrada e o resultado compartilham o tipo de elemento.

Na primeira chamada, Java infere T como Integer. O resultado pode então ser desempacotado em um int. Na segunda chamada, <String> é um argumento de tipo explícito de método, colocado entre o ponto e o nome do método. Lists.last(...) inferiria o mesmo tipo aqui. Um argumento explícito precisa de um receptor antes do ponto: um nome de classe para um método estático ou um objeto como this para um método de instância.

Esse método espera uma lista não vazia. Em uma lista vazia, size() - 1 é -1, portanto get lança IndexOutOfBoundsException. Genéricos verificam tipos; eles não comprovam que um índice existe.

Relacione vários tipos

Um método genérico pode introduzir vários parâmetros. Dada uma classe Pair<K, V> com um construtor e métodos de acesso, este método completo inverte os papéis:

static <K, V> Pair<V, K> swap(Pair<K, V> p) {
    return new Pair<>(p.getSecond(), p.getFirst());
}

Para um par de entrada ("Ada", 36) do tipo Pair<String, Integer>, o resultado é (36, "Ada") do tipo Pair<Integer, String>. A declaração de retorno mantém a relação; um tipo de retorno Object a ocultaria e obrigaria quem chama o método a fazer uma conversão explícita.

Um método como <T> int countEqual(List<T> list, T target) também relaciona entradas. Seu laço pode comparar cada item com target usando equals. Com ["a", "b", "a", "c", "a"] e "a", a contagem é 3. A inferência pode escolher um supertipo comum para os argumentos, portanto repetir T nem sempre obriga duas expressões de argumento a ter tipos declarados idênticos.

Decida a quem pertence o parâmetro de tipo

Uma Box<String> mantém seu argumento de tipo para o uso desse objeto. Lists.last escolhe um argumento de tipo novamente a cada chamada. Uma classe utilitária comum pode, portanto, conter métodos estáticos genéricos sem ser genérica.

Um método estático dentro de Box<T> não pode usar o T da classe: o método estático pertence à classe compartilhada, não a uma caixa. Declare um parâmetro separado, por exemplo static <E> Box<E> of(E value). Se uma declaração de método começar com static T first(...) sem um <T> do método, o compilador informará que não consegue encontrar T em uma classe comum. Adicione a declaração antes do tipo de retorno; mudar o tipo de retorno para Object descartaria a relação útil.

Um T sem restrições oferece apenas operações disponíveis em Object. Limites acrescentam uma garantia útil. Curingas permitem que um parâmetro aceite uma família de tipos genéricos sem supor que todos os seus tipos de elemento sejam idênticos.

Exija as operações necessárias

static <T extends Comparable<T>> T largest(List<T> list) {
    T best = list.get(0);
    for (T x : list) {
        if (x.compareTo(best) > 0) {
            best = x;
        }
    }
    return best;
}

O limite indica que um T pode comparar a si mesmo com outro T. Começando com 3, a chamada largest(List.of(3, 11, 7)) substitui o melhor valor por 11 e depois o mantém para 7. Ela retorna 11. Para ["pear", "apple", "plum"], a maior palavra é "plum" na ordem natural. Uma lista vazia falha em get(0).

extends também introduz limites para interfaces. <T extends Number> disponibiliza doubleValue(). Múltiplos limites usam &, com uma classe primeiro, se houver: <T extends Number & Comparable<T>>.

Por que List não é List

Integer estende Number, mas List<Integer> não é um subtipo de List<Number>. Tipos genéricos são invariantes. Se essa atribuição fosse permitida, o código que usa a referência List<Number> poderia adicionar um Double; quem mantém a lista original o leria então como um Integer. Um parâmetro List<Number> aceita implementações como ArrayList<Number>, mas rejeita List<Integer>.

Leia com extends; adicione com super

static double sum(List<? extends Number> nums) {
    double total = 0;
    for (Number n : nums) total += n.doubleValue();
    return total;
}

static void addOneToThree(List<? super Integer> target) {
    target.add(1);
    target.add(2);
    target.add(3);
}

? extends Number significa um tipo desconhecido que é Number ou um subtipo. sum aceita listas de inteiros, doubles ou números. Ele lê cada elemento como um Number. sum(List.of(1.5, 2.5)) fornece 4,0. Ele não pode adicionar 3: o tipo desconhecido dos elementos pode ser Double. As regras de tipo permitem adicionar null, embora uma lista específica possa rejeitá-lo em tempo de execução.

? super Integer significa Integer ou um supertipo. O segundo método pode adicionar inteiros a uma List<Integer>, List<Number> ou List<Object> modificável. Uma leitura por meio desse parâmetro tem apenas o tipo Object: os elementos existentes podem ser outros números ou objetos.

O recurso de memorização é produtor usa extends, consumidor usa super. Ele descreve a direção da transferência dos elementos, não se toda a coleção é imutável. Por exemplo, ainda pode ser possível remover elementos por meio de uma visão com extends.

Use um parâmetro nomeado quando um tipo precisar relacionar várias posições, especialmente uma entrada e um tipo de retorno. Use um curinga quando apenas uma variedade de entradas aceitas importar. Collections.copy lê de List<? extends T> e escreve em List<? super T>; seu destino já deve ter posições suficientes para substituir.

Genéricos fornecem ao compilador mais informações do que um teste comum de classe em tempo de execução possui. Compreender o que resta após a compilação explica os avisos de tipo bruto e várias operações que Java rejeita.

O que o apagamento remove

Java verifica os argumentos de tipo e depois apaga os parâmetros de tipo, substituindo-os por seus limites. Um T sem limite se torna Object; um T extends Number se torna Number. O compilador insere conversões explícitas onde necessário quando valores são lidos. Existe uma única classe Box em tempo de execução, portanto isto exibe true:

System.out.println(
    new Box<String>("a").getClass()
    == new Box<Integer>(1).getClass()
);

A declaração de Box pode ser a classe genérica com um campo de valor, construtor e método de acesso. Ambas as construções têm a mesma classe em tempo de execução, embora seus usos declarados tenham verificações de compilação diferentes.

Operações que precisam de um tipo conhecido em tempo de execução

Dentro de uma classe genérica, new T() não compila. Java não sabe qual construtor o tipo fornecido possui. Aceite uma fábrica para criar o valor:

import java.util.ArrayList;
import java.util.List;
import java.util.function.Supplier;

class Factory {
    static <T> T create(Supplier<T> factory) {
        return factory.get();
    }

    public static void main(String[] args) {
        List<String> words = create(ArrayList::new);
        words.add("ready");
        System.out.println(words); // [ready]
    }
}

O fornecedor disponibiliza o comportamento de criação. new T[10] e new List<Integer>[2] também são rejeitados como criação de vetor genérico. Armazene uma sequência em ArrayList<T> quando você não precisar do comportamento de um vetor.

Para um Object obj, obj instanceof List<String> não pode testar com segurança o argumento de elemento. Use obj instanceof List<?> para testar se ele é uma lista e depois trate seus elementos como desconhecidos. Esse teste não estabelece que os elementos sejam do tipo string.

Membros estáticos compartilhados e sobrecargas após apagamento

Um campo como static T shared não pode usar o T da classe que o contém. Todas as parametrizações compartilham o membro estático. Um método estático pode introduzir seu próprio <E>, independente do parâmetro da classe.

Duas sobrecargas print(Set<String> s) e print(Set<Integer> s) não podem coexistir em uma classe. Ambas são reduzidas pelo apagamento a um método que aceita Set, causando um conflito de nomes. Dê nomes diferentes às operações ou projete um método que trate o comportamento comum.

Siga um aviso de operação não verificada até a leitura incorreta

List raw = new ArrayList();
raw.add("text");
raw.add(42);
for (Object value : raw) {
    String text = (String) value;
    System.out.println(text);
}

Isso exibe text, depois a conversão explícita de 42 lança ClassCastException. A declaração bruta pode gerar um diagnóstico de tipo bruto; as adições geram avisos de chamadas não verificadas porque as verificações de genéricos foram contornadas. Substituí-la por List<String> transfere a falha para add(42) na compilação. Um aviso de operação não verificada sinaliza a perda de uma garantia, um risco de falha na execução. Corrija o uso bruto ou a conversão insegura em vez de presumir que uma leitura posterior será segura.

Um método pode aceitar uma regra como argumento. Uma expressão lambda escreve essa regra onde ela é usada, enquanto uma interface funcional informa a Java quais entradas a regra recebe e o que ela retorna.

Atenda a um método abstrato

Uma interface funcional tem um método abstrato a implementar. Declarações que correspondem a métodos públicos de instância de Object, como equals(Object), não contam. Métodos padrão e estáticos não acrescentam trabalho abstrato. Comparator<T> e Runnable são interfaces funcionais.

@FunctionalInterface
interface Operation {
    int apply(int a, int b);
}

class Combine {
    static int combine(int a, int b, Operation op) {
        return op.apply(a, b);
    }

    public static void main(String[] args) {
        Operation add = (a, b) -> a + b;
        System.out.println(add.apply(3, 4)); // 7
        System.out.println(combine(3, 4, (x, y) -> x * y)); // 12
    }
}

A interface fornece o nome do método apply, os dois tipos de parâmetro int e o tipo de resultado int. A expressão lambda fornece os nomes dos parâmetros e o corpo. Ela cria uma implementação utilizável por meio de Operation; não chama apply até que o programa o invoque.

combine sempre passa seus dois números para op. Quem chama o método altera o comportamento ao fornecer uma adição ou multiplicação. É assim também que sort recebe uma regra de ordenação e filter recebe uma condição.

Leia a sintaxe

Uma expressão lambda tem parâmetros, -> e depois uma expressão ou um bloco. Um único parâmetro inferido pode dispensar parênteses: w -> w.length() > 5. Nenhum parâmetro exige (), e dois ou mais exigem parênteses, como em (a, b) -> a * b. Tipos explícitos são permitidos: (int a, int b) -> a + b.

Um corpo de expressão retorna seu resultado automaticamente. Um bloco que produz um valor deve retorná-lo:

Operation max = (a, b) -> {
    if (a > b) {
        return a;
    }
    return b;
};
System.out.println(max.apply(3, 9)); // 9

Todo caminho nesse bloco retorna um int. Acrescentar chaves em torno de a + b sem return não cria um bloco válido que retorna valor.

Deixe o destino fornecer o significado

O tipo de destino é a interface funcional esperada em uma atribuição, argumento ou posição de retorno. O texto x -> x * 2 pode corresponder a Function<Integer, Integer> ou UnaryOperator<Integer>. Seus tipos de parâmetro e de resultado vêm desse destino. Object o = () -> 1; falha porque Object não fornece um método funcional.

@FunctionalInterface solicita que o compilador verifique a definição da interface. É uma proteção útil caso alguém acrescente posteriormente um segundo método abstrato distinto. Sem a anotação, essa interface ainda pode ser declarada, mas uma expressão lambda não pode implementar suas duas exigências independentes.

Uma expressão lambda também pode entrar em conflito com nomes locais. Se o método que a contém já declarar int a, ele não poderá declarar um parâmetro de expressão lambda chamado a nesse escopo. Escolha outro nome de parâmetro. Em comparação com uma classe anônima que implementa Comparator<String>, uma expressão lambda elimina a repetição da declaração de classe e método; o cálculo da ordenação ainda precisa atender ao contrato do comparador.

Java já nomeia as formas comuns de comportamento. Escolha uma interface pelo número de entradas e pelo tipo de resultado e depois chame seu método funcional para executar o comportamento.

Escolha uma forma de entrada e saída

Essas interfaces estão em java.util.function. Para cadeias de caracteres, w -> w.length() > 5 corresponde a um predicado, String::length corresponde a uma função que retorna Integer, e System.out::println corresponde a um consumidor. Um fornecedor como () -> new ArrayList<String>() cria uma nova lista sempre que get() é executado. Uma condição usada por filter precisa de Predicate<T>, embora uma Function<T, Boolean> também possa calcular um valor booleano em outro código.

UnaryOperator<T> é uma função de T para o mesmo T. BinaryOperator<T> combina dois valores do tipo T em um T. BiFunction<T, U, R>, BiPredicate<T, U> e BiConsumer<T, U> recebem duas entradas. Formas para tipos primitivos evitam o empacotamento: IntPredicate.test(int), IntBinaryOperator.applyAsInt(int, int) e ToIntFunction<T>.applyAsInt(T).

Combine regras em uma ordem definida

import java.util.function.Function;
import java.util.function.Predicate;

class Rules {
    public static void main(String[] args) {
        Predicate<String> isLong = w -> w.length() > 5;
        Predicate<String> longB = isLong.and(w -> w.startsWith("b"));
        System.out.println(longB.test("banana")); // true
        System.out.println(isLong.negate().test("kiwi")); // true

        Function<Integer, Integer> twice = x -> x * 2;
        Function<Integer, Integer> inc = x -> x + 1;
        System.out.println(twice.andThen(inc).apply(5)); // 11
        System.out.println(twice.compose(inc).apply(5)); // 12
    }
}

and exige ambas as condições, or exige pelo menos uma, e negate inverte a resposta. Predicate.not(p) também nega um predicado. andThen executa primeiro o receptor; compose executa primeiro seu argumento. Aqui, a primeira cadeia calcula 10 e depois 11, enquanto a segunda calcula 6 e depois 12.

Passe uma regra para um método

static <T> List<T> keep(List<T> list, Predicate<T> test) {
    List<T> kept = new ArrayList<>();
    for (T x : list) {
        if (test.test(x)) kept.add(x);
    }
    return kept;
}

keep(List.of(4, 9, 12, 15), n -> n % 3 == 0) fornece [9, 12, 15]. T permite reutilizar o método com diferentes tipos de elemento; o predicado permite reutilizar o comportamento de seleção.

Para uma lista modificável [3, 8, 1, 10, 6], removeIf(n -> n < 5) deixa [8, 10, 6]. replaceAll(n -> n * 2) fornece então [16, 20, 12]. Esses métodos alteram a lista; forEach aceita um consumidor para ações como exibição. Copie um resultado de List.of(...) para um ArrayList antes de usar operações que o modifiquem.

Para mapas, forEach((key, value) -> ...) recebe um BiConsumer. merge(word, 1, Integer::sum) armazena 1 para uma palavra nova e incrementa uma contagem existente. computeIfAbsent(key, k -> new ArrayList<>()) cria um valor para uma chave ausente ou associada a null e retorna o valor resultante. Esses métodos mantêm juntas a consulta e a regra de atualização.

Uma expressão lambda pode usar informações do método que a contém. Quando seu corpo apenas chama um método existente, uma referência a método costuma expressar o mesmo comportamento de forma mais direta.

Capture uma variável local

int limit = 10;
Predicate<Integer> small = n -> n < limit;
System.out.println(small.test(7)); // true

A expressão lambda captura limit. Uma variável local capturada deve ser final ou efetivamente final: recebe um valor uma vez e nunca é reatribuída. Adicionar limit = 20; em qualquer lugar após essa primeira atribuição faz a captura falhar na compilação, mesmo que a reatribuição apareça antes da expressão lambda.

A regra se aplica à variável local, não a todo o estado dentro de seu objeto. Isto compila:

StringBuilder log = new StringBuilder();
Runnable action = () -> log.append("ran");
action.run();
System.out.println(log); // ran

log continua referenciando o mesmo construtor de texto. Atualizar um campo do objeto que contém a expressão também é permitido, mas alterações ocultas podem dificultar o acompanhamento do comportamento.

Tentar numbers.forEach(n -> total += n) com uma variável local int total = 0 falha porque altera a variável capturada. Use um laço quando a tarefa for uma atualização ou calcule um resultado diretamente com numbers.stream().mapToInt(n -> n).sum().

Leia as quatro formas de referência

Uma referência a método usa ::, sem lista de argumentos. A interface funcional de destino fornece as entradas e o resultado esperado.

Na referência vinculada, o receptor já está fixado: o PrintStream referenciado por System.out. Na referência não vinculada, o primeiro argumento funcional se torna o receptor. Assim, String::compareToIgnoreCase equivale a (a, b) -> a.compareToIgnoreCase(b): a primeira cadeia de caracteres é o receptor e a segunda é o argumento do método.

Associe a referência a um destino

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.function.Supplier;

class References {
    public static void main(String[] args) {
        Function<String, Integer> parse = Integer::parseInt;
        Function<String, Integer> length = String::length;
        Supplier<List<String>> fresh = ArrayList::new;
        System.out.println(parse.apply("42")); // 42
        System.out.println(length.apply("stream")); // 6
        System.out.println(fresh.get()); // []
    }
}

Uma referência a construtor também pode receber argumentos. Student::new corresponde a uma Function<String, Student> quando um construtor compatível recebe uma String. O destino determina qual sobrecarga de construtor é selecionada.

Student::getName referencia um método de acesso de instância em cada estudante fornecido; não exige um método de acesso estático. Escreva uma expressão lambda quando houver trabalho adicional, como em s -> s.getPoints() * 2 ou w -> w.length() > 5. Escrever String::length() é inválido: a referência nomeia um comportamento sem invocá-lo nesse ponto.

A ordem natural de um objeto nem sempre é a ordem necessária para uma tarefa. Um Comparator<T> separado permite ordenar os mesmos objetos por regras diferentes sem alterar sua classe.

Leia o sinal de compare

compare(a, b) retorna um número negativo quando a vem primeiro, zero quando os dois têm a mesma posição e um número positivo quando a vem depois de b. Apenas o sinal importa. Um comparador não retorna um valor booleano.

Comparable<T> pertence à classe e fornece sua ordem natural por meio de compareTo. Um comparador é um valor separado passado a um método de ordenação. Cadeias de caracteres têm uma ordem natural de caracteres, mas um comparador pode ordená-las por comprimento.

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

class SortWords {
    public static void main(String[] args) {
        List<String> words = new ArrayList<>(List.of("ccc", "a", "bb"));
        Comparator<String> byLength =
            (a, b) -> Integer.compare(a.length(), b.length());
        words.sort(byLength);
        System.out.println(words); // [a, bb, ccc]
    }
}

O comparador extrai os comprimentos e compara os números. words.sort altera a lista modificável e retorna void; ele não retorna uma nova lista. Ordenar um resultado de List.of(...) lança UnsupportedOperationException, portanto o exemplo primeiro cria uma cópia em um ArrayList.

Compare números com segurança

Use Integer.compare ou Double.compare. A subtração pode inverter o sinal por estouro: 2_000_000_000 - (-2_000_000_000) resulta em -294.967.296 como um int. Isso coloca incorretamente o número maior primeiro em ordem crescente. Integer.compare(2_000_000_000, -2_000_000_000) retorna corretamente 1.

Converter explicitamente uma diferença de doubles em int também perde informações. (int) (1.2 - 0.7) é 0, embora o primeiro valor seja maior. Double.compare(1.2, 0.7) informa um resultado positivo.

Mantenha a ordenação consistente

Inverter as entradas deve inverter o sinal da comparação. Se a vem antes de b e b antes de c, a deve vir antes de c. Valores cuja comparação resulta em zero devem ter a mesma posição em relação a qualquer outro valor. Violar essas regras pode produzir uma ordem incorreta ou fazer a ordenação lançar IllegalArgumentException com “Comparison method violates its general contract!”. Retornar apenas 0 ou 1 não consegue expressar as duas direções.

As ordenações de listas de Java e as ordenações de vetores de objetos baseadas em comparador são estáveis: empates mantêm sua ordem original. Para os estudantes Ada 85, Ben 72, Chen 85, Dara 90 e Eli 64, ordenar por pontos em ordem crescente fornece Eli, Ben, Ada, Chen, Dara. Ada permanece antes de Chen porque eles empatam e Ada apareceu primeiro.

Os exemplos de estudantes usam esta classe e uma lista modificável:

class Student {
    private final String name;
    private final String group;
    private final int points;

    Student(String name, String group, int points) {
        this.name = name;
        this.group = group;
        this.points = points;
    }
    String getName() { return name; }
    String getGroup() { return group; }
    int getPoints() { return points; }
}

List<Student> students = new ArrayList<>(List.of(
    new Student("Ada", "A", 85), new Student("Ben", "B", 72),
    new Student("Chen", "A", 85), new Student("Dara", "B", 90),
    new Student("Eli", "A", 64)));
students.sort(Comparator.comparingInt(Student::getPoints));
students.forEach(s -> System.out.println(s.getName()));
// Eli, Ben, Ada, Chen, Dara, each on a separate line

Escolha uma forma de ordenar

list.sort(cmp) e Collections.sort(list, cmp) alteram uma lista modificável. list.sort(null) solicita a ordem natural. Arrays.sort(array, cmp) aceita um vetor de objetos como Integer[]; um int[] não tem uma sobrecarga que aceite comparador.

A ordem natural de cadeias de caracteres compara unidades de código UTF-16. As maiúsculas A–Z precedem as minúsculas a–z, portanto ["banana", "Cherry", "apple"] se torna [Cherry, apple, banana]. String.CASE_INSENSITIVE_ORDER fornece [apple, banana, Cherry] para essas palavras. Escolha explicitamente a regra para o texto quando maiúsculas e minúsculas não devam determinar a ordem.

Uma ordenação por várias chaves é mais fácil de ler como uma sequência de decisões: compare a chave principal e depois compare uma segunda chave apenas se houver empate na primeira. Os métodos de construção de comparadores expressam essas decisões diretamente.

Extraia uma chave e resolva empates

Para um Student com getName(), getGroup() e getPoints(), Comparator.comparing(Student::getName) ordena por nome. comparingInt(Student::getPoints) extrai um int sem empacotá-lo.

Comparator<Student> ranking =
    Comparator.comparingInt(Student::getPoints)
        .reversed()
        .thenComparing(Student::getName);

Isso coloca as maiores pontuações primeiro e depois os nomes em ordem crescente em caso de pontuações iguais. Para Ada (A, 85), Ben (B, 72), Chen (A, 85), Dara (B, 90), Eli (A, 64), fornece Dara, Ada, Chen, Ben, Eli. A comparação de nomes é executada apenas em caso de empate em pontos.

Coloque reversed no nível correto

reversed() inverte tudo o que foi construído antes dele. Inverter a classificação após thenComparing também inverteria os nomes dentro de cada empate de pontuação. Para ordenar grupos em ordem crescente e pontos em ordem decrescente dentro de cada grupo, inverta apenas o comparador de pontos:

Comparator<Student> byGroup =
    Comparator.comparing(Student::getGroup)
        .thenComparing(
            Comparator.comparingInt(Student::getPoints).reversed());

O resultado é Ada, Chen, Eli, Dara, Ben: o grupo A precede B; dentro de A, 85 precede 64. Colocar .reversed() no final inverteria tanto a ordem dos grupos quanto a dos pontos em relação à cadeia anterior.

Escolha regras para texto e valores nulos

Comparator.naturalOrder() segue Comparable; reverseOrder() inverte essa ordem. Forneça um comparador de chave quando uma chave precisar de tratamento especial, como em Comparator.comparing(Student::getName, String.CASE_INSENSITIVE_ORDER).

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

class SortNullable {
    public static void main(String[] args) {
        List<String> words = new ArrayList<>();
        words.add("b");
        words.add(null);
        words.add("a");
        words.sort(Comparator.nullsFirst(Comparator.naturalOrder()));
        System.out.println(words); // [null, a, b]
    }
}

Envolva a comparação no nível em que ocorre o valor nulo. nullsLast em torno de todo o comparador de estudantes trata objetos de estudante nulos. Um extrator de nome que retorna null precisa de um comparador que trate valores nulos para a própria chave de nome. Comparadores de ordem natural e comparadores comuns de chave não tratam automaticamente chaves nulas.

Ordene entradas de mapa e resolva a inferência

Um HashMap não garante uma ordem de encontro. Crie um fluxo de suas entradas e escolha uma ordem explicitamente:

stock.entrySet().stream()
    .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
    .forEach(System.out::println);

Para rice=12, oats=3 e flour=7, isso exibe rice=12, flour=7, oats=3, em linhas separadas. A operação ordena as entradas do fluxo sem reorganizar stock. Adicione thenComparing(Map.Entry.comparingByKey()) se valores empatados precisarem de uma ordem previsível por chave.

O <String, Integer> explícito ajuda na inferência ao longo da chamada encadeada. Da mesma forma, Comparator.comparing(s -> s.getName()).reversed() pode inferir s como Object. Use Student::getName ou (Student s) -> s.getName() para fornecer o tipo que falta. Um comparador nomeado pode ser reutilizado na ordenação de listas, em sorted, min e max de fluxos ou em um mapa ou conjunto ordenado.

Um fluxo de elementos descreve como processar uma sequência de valores. Ele lê de uma fonte, passa os elementos por operações intermediárias e termina com uma operação terminal que produz um resultado ou executa uma ação.

Identifique as três partes

import java.util.List;

class CountPasses {
    public static void main(String[] args) {
        List<Integer> points = List.of(72, 45, 90, 58, 81);
        long passed = points.stream()
            .filter(p -> p >= 60)
            .count();
        System.out.println(passed); // 3
        System.out.println(points); // [72, 45, 90, 58, 81]
    }
}

points.stream() é a fonte. filter é uma operação intermediária: retorna outro fluxo. count é a operação terminal: retorna um long. Os valores 72, 90 e 81 passam pelo filtro. A leitura por meio do fluxo não removeu 45 nem 58 de points.

Escolha uma fonte

Coleções disponibilizam stream(). Um mapa disponibiliza fluxos por meio de entrySet(), keySet() ou values(). Arrays.stream(array) cria um fluxo dos elementos de um vetor; um int[] produz um IntStream. Stream.of("a", "b", "c") fornece os valores listados.

IntStream.range(1, 5) contém 1, 2, 3, 4, com o limite final excluído. rangeClosed(1, 5) inclui 5 e sua soma é 15. Stream.iterate(1, n -> n * 2) não tem limite final fixo; .limit(5).toList() coleta [1, 2, 4, 8, 16]. Um resultado limitado é essencial ao consumir essa sequência infinita.

Acompanhe a avaliação preguiçosa

Operações intermediárias têm avaliação preguiçosa. Apenas escrever names.stream().map(String::toUpperCase); não executa as transformações. Uma operação terminal inicia o processamento, e os elementos são consumidos apenas conforme a necessidade.

String first = java.util.stream.Stream.of("one", "two", "three", "four")
    .filter(w -> w.length() > 3)
    .map(String::toUpperCase)
    .findFirst()
    .orElse("none");
System.out.println(first); // THREE

As duas primeiras palavras não passam pelo filtro. "three" passa, torna-se "THREE" e satisfaz findFirst. A última palavra não é necessária. Isso é curto-circuito: a resposta se torna conhecida antes que toda a fonte seja lida.

sorted precisa de toda a entrada antes de emitir o primeiro valor ordenado. Algumas outras operações com estado, como distinct sequencial, podem emitir valores à medida que a entrada chega. A posição de uma operação na cadeia afeta a quantidade de trabalho necessária.

Crie um novo fluxo para outro resultado

Após uma operação terminal, o fluxo é consumido. Reutilizá-lo geralmente lança IllegalStateException com “stream has already been operated upon or closed”. Chame points.stream() novamente para outra cadeia de processamento. Uma coleção é um armazenamento reutilizável; um fluxo é um caminho de processamento.

Criar um fluxo não copia seus elementos. Mantenha a fonte inalterada durante o processamento. map produz valores transformados; ele não os grava de volta na lista. Para alterações intencionais na lista, métodos como replaceAll e removeIf expressam essa tarefa diretamente. Use uma operação por linha para manter visíveis a ordem do processamento e o tipo de resultado.

Acompanhe tanto os valores quanto seu tipo após cada operação: uma expressão lambda posterior recebe o elemento atual do fluxo, não o objeto original da fonte.

Selecione antes de transformar

filter mantém os elementos que passam por um predicado. map substitui cada elemento por um valor calculado. Dados estudantes com métodos de acesso a nome e pontos, a seleção por pontos deve acontecer antes da transformação em nomes:

List<String> names = students.stream()
    .filter(s -> s.getPoints() >= 80)
    .map(Student::getName)
    .sorted()
    .toList();

Para Ada 85, Ben 72, Chen 85, Dara 90 e Eli 64, isso produz [Ada, Chen, Dara]. Antes de map, o tipo de elemento é Student. Depois, o tipo é String, portanto um método de acesso aos pontos não está mais disponível.

Passe para um fluxo de tipo primitivo

Stream<Integer> contém referências a objetos empacotadores e não tem método sum(). mapToInt(Integer::intValue) produz um IntStream, que fornece operações numéricas. mapToInt(String::length) também mede cadeias de caracteres como comprimentos primitivos.

import java.util.List;
import java.util.stream.IntStream;

class Windows {
    public static void main(String[] args) {
        List<Integer> window = IntStream.rangeClosed(1, 10)
            .skip(2)
            .limit(3)
            .boxed()
            .toList();
        System.out.println(window); // [3, 4, 5]
    }
}

skip(2) remove 1 e 2 do fluxo. limit(3) mantém os três valores seguintes. Inverter essas chamadas deixa apenas 3. boxed() retorna a Stream<Integer> para que os elementos possam ser coletados como objetos. mapToObj cria outros objetos a partir de valores primitivos; fluxos de long e double têm operações de conversão correspondentes.

Remova duplicatas e escolha uma ordem

distinct usa a igualdade de objetos. ["map", "filter", "map", "sorted", "filter"] torna-se [map, filter, sorted], e depois sorted() fornece [filter, map, sorted]. Para suas próprias classes, implemente equals e hashCode consistentes se valores iguais nos campos devem ser considerados duplicatas.

sorted() usa a ordem natural. Forneça um comparador para outra ordem ou para objetos sem ordem natural. A ordenação de um fluxo ordenado é estável. Ordenar os cinco estudantes por pontos em ordem decrescente e depois pegar dois seleciona Dara e Ada: Ada precede Chen na lista original, na qual suas pontuações estão empatadas. Chamar limit(2) antes da ordenação examinaria apenas os dois primeiros estudantes originais.

Achate sequências aninhadas

List<Integer> all = List.of(
        List.of(1, 2), List.of(3), List.of(4, 5, 6))
    .stream()
    .flatMap(List::stream)
    .toList();
System.out.println(all); // [1, 2, 3, 4, 5, 6]

Cada lista interna se torna um fluxo, e flatMap une seus elementos em um único fluxo. Substituir flatMap por map aqui fornece um Stream<Stream<Integer>>: um objeto de fluxo por lista interna, sem achatá-la.

peek passa um valor adiante sem alterá-lo e pode exibi-lo para depuração. Sua ação é executada apenas para os elementos realmente percorridos, e uma implementação pode pular uma etapa desnecessária, por exemplo ao otimizar count. Não o use para realizar trabalho obrigatório. Para um único valor máximo, use max(comparator) em vez de ordenar todos os elementos e pegar um.

Escolha a operação terminal conforme o resultado necessário: uma contagem, um número, um valor de verdade, um elemento ou uma combinação geral. A entrada vazia importa sempre que não for possível escolher um valor de resultado.

Calcule um número

count() retorna um long. sum() de um fluxo de tipo primitivo retorna um número do tipo primitivo do fluxo. Para os pontos [72, 45, 90, 58, 81], filtrar os valores de pelo menos 60 e depois somar fornece 243. A média desses três valores é 81,0.

import java.util.List;

class PointResults {
    public static void main(String[] args) {
        List<Integer> points = List.of(72, 45, 90, 58, 81);
        int sum = points.stream().filter(p -> p >= 60)
            .mapToInt(Integer::intValue).sum();
        double average = points.stream().filter(p -> p >= 60)
            .mapToInt(Integer::intValue).average().orElse(0.0);
        System.out.println(sum);     // 243
        System.out.println(average); // 81.0
    }
}

A segunda cadeia usa um novo fluxo. Uma soma vazia é 0, mas uma média vazia não tem valor. average() retorna OptionalDouble, e orElse(0.0) fornece um valor alternativo escolhido. Esse valor padrão é uma decisão do programa, não a média matemática de um conjunto vazio.

Uma soma int pode sofrer estouro. Somar dois valores de 2.000.000.000 produz -294.967.296 como um int. Converta antes de somar: mapToInt(...).asLongStream().sum() fornece 4.000.000.000 como um long.

Trate um valor ou nenhum

Um Optional<T> contém um valor ou nenhum valor. min, max, findFirst, findAny e redução sem elemento neutro em fluxos de objetos retornam valores opcionais. points.stream().max(Integer::compare) fornece Optional[90]; exibir o contêiner inclui o texto que envolve o valor.

Use orElse para um valor alternativo, orElseGet para um fornecedor de valor alternativo, ifPresent para uma ação ou map para transformar um valor presente. Filtrar por um estudante com mais de 95 pontos, transformar a primeira correspondência em um nome e aplicar orElse("nobody") fornece "nobody" para os dados dos cinco estudantes. Chamar get() ou orElseThrow() em um valor opcional vazio lança NoSuchElementException.

Faça uma pergunta de verdadeiro ou falso

anyMatch pergunta se pelo menos um valor passa, allMatch se todos os valores passam e noneMatch se nenhum passa. Eles podem parar assim que a resposta for conhecida. Em uma entrada vazia, anyMatch é falso, enquanto allMatch e noneMatch são verdadeiros: não há valor que viole qualquer uma das duas afirmações universais.

Combine com um elemento neutro

Stream.of(3, 5, 7).reduce(0, Integer::sum) acumula 0, 3, 8, 15. Para multiplicação, comece com 1 e use (a, b) -> a * b para obter 105. Um elemento neutro deixa um valor inalterado sob a operação; 10 não é um elemento neutro da adição e deslocaria incorretamente o total para 25. O acumulador deve ser associativo para que o agrupamento não altere o resultado.

Sem elemento neutro, reduce(Integer::max) fornece Optional[7] e um valor opcional vazio para uma entrada vazia. Já forEach executa uma ação e retorna void; ele é adequado para exibição. Use redução ou coleta quando a tarefa for produzir um valor como resultado.

Um coletor transforma um fluxo em uma estrutura de resultado útil. Decida o que o resultado deve permitir: duplicatas, ordenação, alterações posteriores ou chaves de mapa duplicadas. Coletores diferentes oferecem garantias diferentes.

Escolha uma lista ou um conjunto

stream.toList() retorna uma lista não modificável em ordem de encontro. Adicionar ou remover elementos lança UnsupportedOperationException. collect(Collectors.toList()) também coleta uma lista, mas não garante uma implementação específica nem a possibilidade de modificação. Para uma lista que você vai alterar, solicite-a explicitamente:

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

class Gather {
    public static void main(String[] args) {
        List<String> words = Stream.of("a", "b", "a")
            .collect(Collectors.toCollection(ArrayList::new));
        words.add("c");
        System.out.println(words); // [a, b, a, c]
        System.out.println(Stream.of("a", "b", "a")
            .collect(Collectors.toSet()).size()); // 2
    }
}

toSet remove duplicatas e não garante ordem. toCollection(TreeSet::new) solicita um conjunto ordenado. Uma lista mantém elementos duplicados; escolha um conjunto quando o resultado representar valores distintos.

Una texto

Collectors.joining(", ") une cadeias de caracteres com um separador, sem um separador ao final. Sua forma com três argumentos também adiciona um prefixo e um sufixo:

String names = Stream.of("Ada", "Chen", "Dara")
    .collect(Collectors.joining(", ", "[", "]"));
System.out.println(names); // [Ada, Chen, Dara]

Os elementos devem ser valores CharSequence, normalmente cadeias de caracteres. Transforme estudantes com Student::getName ou números com String::valueOf antes da junção. A junção retorna uma cadeia de caracteres, não uma lista que apenas é exibida de forma semelhante.

Escolha chaves e valores do mapa

Collectors.toMap(keyFunction, valueFunction) calcula uma entrada a partir de cada elemento. Com os cinco estudantes Ada (A, 85), Ben (B, 72), Chen (A, 85), Dara (B, 90), Eli (A, 64), associar nomes a pontos fornece cinco entradas, como Ada=85 e Eli=64.

Chaves de agrupamento são diferentes: vários estudantes têm o mesmo grupo. Um toMap(Student::getGroup, Student::getPoints) com dois argumentos lança IllegalStateException quando uma chave se repete, mesmo que ambos os valores sejam 85. Um mapa precisa de um único valor resultante por chave, e essa forma não fornece uma regra para escolhê-lo.

Forneça um terceiro argumento para mesclar duplicatas:

Map<String, Integer> totals = students.stream()
    .collect(Collectors.toMap(
        Student::getGroup, Student::getPoints, Integer::sum));

O grupo A recebe 85 + 85 + 64 = 234; o grupo B recebe 72 + 90 = 162. Substituir Integer::sum por Math::max mantém a maior pontuação por grupo, A=85 e B=90. Use a regra que responde à tarefa, não um primeiro valor arbitrário.

toMap não garante uma ordem específica para o mapa. Um quarto argumento pode solicitar uma, por exemplo TreeMap::new para chaves ordenadas. toMap(Student::getName, Student::getPoints, (a, b) -> a, TreeMap::new) mantém o primeiro valor em nomes duplicados e ordena por nome. Um coletor também evita criar uma lista externa e alterá-la em forEach; o resultado é construído pela operação projetada para reuni-lo.

Um resultado agrupado responde a uma pergunta para cada chave. Uma partição responde a uma pergunta de sim ou não com dois grupos. Um coletor subsequente determina o que cada grupo armazena.

Agrupe por uma chave calculada

groupingBy(classifier) produz um mapa de cada chave encontrada para uma lista de seus elementos. Agrupar ["fig", "kiwi", "pear", "plum", "apple", "mango", "banana"] por comprimento da palavra fornece a lista [kiwi, pear, plum] para o comprimento 4. Comprimentos ausentes não têm entrada; consultá-los retorna null, portanto use getOrDefault(key, List.of()) quando uma lista vazia for útil.

import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.stream.Collectors;

class WordGroups {
    public static void main(String[] args) {
        List<String> words = List.of(
            "fig", "kiwi", "pear", "plum", "apple", "mango", "banana");
        Map<Integer, Long> counts = words.stream()
            .collect(Collectors.groupingBy(
                String::length, TreeMap::new, Collectors.counting()));
        System.out.println(counts); // {3=1, 4=3, 5=2, 6=1}
    }
}

O classificador escolhe chaves inteiras. TreeMap::new ordena essas chaves. counting() substitui a lista de cada grupo por seu tamanho como um Long. O tipo do resultado é, portanto, Map<Integer, Long>, não um mapa de inteiros para inteiros.

Altere o que um grupo armazena

Com os estudantes Ada (A, 85), Ben (B, 72), Chen (A, 85), Dara (B, 90), Eli (A, 64), agrupar por Student::getGroup oferece estas possibilidades:

Um coletor subsequente trabalha dentro de cada grupo. Para A, a média é 234 dividido por 3, ou 78,0; a média de B é 81,0. maxBy e minBy armazenam um Optional contendo o valor extremo de cada grupo. groupingBy simples não garante um tipo de mapa nem uma ordem de chaves específica; sua forma com fábrica de mapas permite uma escolha explícita.

Divida em duas respostas

Map<Boolean, List<String>> partition = students.stream()
    .collect(Collectors.partitioningBy(
        s -> s.getPoints() >= 80,
        Collectors.mapping(Student::getName, Collectors.toList())));

A lista de valores verdadeiros é [Ada, Chen, Dara], e a de valores falsos é [Ben, Eli]. Ambas as chaves booleanas estão presentes, mesmo que um dos lados não tenha estudantes. Com counting() como coletor subsequente, lados vazios contêm 0 como um Long. Já groupingBy com um classificador booleano cria apenas as chaves que ocorrem.

Processe o mapa construído

Um resultado agrupado é um mapa comum. Percorra-o com forEach((group, value) -> ...) ou crie um fluxo de suas entradas. Para as médias A=78,0 e B=81,0, averages.entrySet().stream().max(Map.Entry.comparingByValue()) retorna um Optional<Map.Entry<String, Double>> contendo B=81.0. O valor opcional envolve a entrada vencedora; ele não é o valor simples 81,0. Uma etapa separada pode transformar essa entrada em sua chave ou valor e tratar um mapa vazio.

Uma tarefa completa de dados costuma ter duas etapas: resumir a entrada e depois consultar o resumo. Escolha fluxos de elementos quando essas etapas forem fáceis de ler como operações padrão e laços quando o controle explícito tornar o trabalho mais claro.

Calcule a média das leituras e selecione cidades

Suponha que uma Reading tenha getCity() e getCelsius(). As leituras são Oslo 4,5, Lima 19,0, Oslo 6,0, Cairo 27,5 e Lima 21,0, em graus Celsius.

class Reading {
    private final String city;
    private final double celsius;
    Reading(String city, double celsius) {
        this.city = city;
        this.celsius = celsius;
    }
    String getCity() { return city; }
    double getCelsius() { return celsius; }
}

Crie a lista de entrada antes de qualquer uma das implementações:

List<Reading> readings = List.of(
    new Reading("Oslo", 4.5), new Reading("Lima", 19.0),
    new Reading("Oslo", 6.0), new Reading("Cairo", 27.5),
    new Reading("Lima", 21.0));

Map<String, Double> averages = readings.stream()
    .collect(Collectors.groupingBy(
        Reading::getCity,
        TreeMap::new,
        Collectors.averagingDouble(Reading::getCelsius)));

List<String> warmCities = averages.entrySet().stream()
    .filter(e -> e.getValue() > 15)
    .map(Map.Entry::getKey)
    .toList();

O primeiro resultado é {Cairo=27.5, Lima=20.0, Oslo=5.25}. A média de Oslo é (4.5 + 6.0) / 2, ou 5,25. A de Lima é 20,0. O segundo resultado é [Cairo, Lima]; o TreeMap fornece a ordem crescente das cidades. Filtre as médias após o agrupamento: filtrar primeiro as leituras individuais responde a outra pergunta.

Para a leitura individual mais quente, use readings.stream().max(Comparator.comparingDouble(Reading::getCelsius)). Ele retorna um valor opcional que contém a leitura de Cairo, não necessariamente a cidade com a maior média. Essas tarefas podem ter respostas diferentes em outros dados.

Expresse o mesmo cálculo com laços

Map<String, List<Double>> byCity = new TreeMap<>();
for (Reading r : readings) {
    byCity.computeIfAbsent(r.getCity(), k -> new ArrayList<>())
        .add(r.getCelsius());
}
Map<String, Double> averages = new TreeMap<>();
for (Map.Entry<String, List<Double>> e : byCity.entrySet()) {
    double sum = 0;
    for (double value : e.getValue()) sum += value;
    averages.put(e.getKey(), sum / e.getValue().size());
}
System.out.println(averages);
// {Cairo=27.5, Lima=20.0, Oslo=5.25}

Estas são implementações alternativas do mesmo resultado; cada grupo não está vazio porque uma leitura o criou. O fluxo torna explícitos o agrupamento e a média em um único coletor. Os laços expõem as listas intermediárias e a soma.

Mantenha o comportamento do processamento previsível

Uma expressão lambda de uma cadeia de processamento deve calcular a partir de sua entrada sem alterar o estado externo. Para os pontos [72, 45, 90, 58, 81], filter(p -> p >= 60).toList() produz diretamente [72, 90, 81]. Adicionar elementos a uma lista externa dentro de forEach oculta essa tarefa de construção do resultado em uma ação.

Não altere uma fonte ArrayList dentro de sua cadeia de processamento: adicionar elementos de dentro de um forEach pode lançar ConcurrentModificationException. Primeiro colete os novos elementos separadamente e depois adicione-os após o término do processamento. Uma referência final capturada pode permitir mutação pelas regras de tipo de Java; isso não torna a mutação adequada dentro de um fluxo.

Escolha o fluxo de controle mais claro

Use um laço quando precisar de índices adjacentes, uma condição de parada complicada ou várias atualizações coordenadas. Use fluxos de elementos para seleção, transformação e coleta legíveis. A sintaxe de fluxo, por si só, não garante velocidade. Nomeie um predicado ou comparador longo e divida uma cadeia longa em um resultado intermediário significativo. Para depurar, inspecione com peek ou colete uma etapa em uma lista e exiba-a; continue a partir de um novo fluxo dessa lista em vez de reutilizar uma cadeia consumida.