1. List (mais usada com lambdas)
– Para manipulação sequencial.

Introdução ao List
O que é?

List é uma interface em Java para manipular coleções ordenadas.
Permite elementos duplicados e acessa os itens pelo índice.

Implementações principais: ArrayList, LinkedList
Motivo: Possui métodos como forEach, removeIf, replaceAll e permite fácil manipulação de elementos usando lambdas.

Implementações Comuns:

ArrayList: Melhor para buscas rápidas devido à estrutura de array.
LinkedList: Melhor para inserções/remoções frequentes, devido à estrutura de lista encadeada.

- Por que usar com lambdas?

O suporte a Streams e métodos funcionais do Java 8+ permite manipular os elementos de forma concisa e declarativa.
Métodos como forEach, removeIf, replaceAll e outros são muito úteis para operações sequenciais.

Principais Métodos de List com Lambdas

- forEach
Executa uma ação para cada elemento da lista.

List<String> nomes = List.of("Ana", "Carlos", "João");
nomes.forEach(nome -> System.out.println("Olá, " + nome));

- removeIf
Remove elementos que satisfazem uma condição.

List<Integer> numeros = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6));
numeros.removeIf(n -> n % 2 == 0); // Remove números pares
System.out.println(numeros); // Saída: [1, 3, 5]

- replaceAll
Substitui cada elemento da lista com base em uma função.

List<String> palavras = new ArrayList<>(List.of("java", "lambda", "stream"));
palavras.replaceAll(String::toUpperCase); // Transforma todas em maiúsculas
System.out.println(palavras); // Saída: [JAVA, LAMBDA, STREAM]

- sort
Ordena a lista com base em um comparador.

List<String> nomes = new ArrayList<>(List.of("Ana", "Carlos", "João"));
nomes.sort((a, b) -> b.compareTo(a)); // Ordena em ordem decrescente
System.out.println(nomes); // Saída: [João, Carlos, Ana]

- stream (transformações e filtros com Streams)
Permite usar operações mais complexas.

List<Integer> numeros = List.of(10, 15, 20, 25);
List<Integer> dobrados = numeros.stream()
                                .map(n -> n * 2) // Dobra os valores
                                .filter(n -> n > 30) // Filtra maiores que 30
                                .toList();
System.out.println(dobrados); // Saída: [40, 50]

- add e remove (com manipulação funcional)

List<String> frutas = new ArrayList<>();
frutas.add("Maçã");
frutas.add("Banana");
frutas.add("Laranja");

frutas.removeIf(f -> f.startsWith("M")); // Remove elementos começando com 'M'
frutas.forEach(System.out::println); // Saída: Banana, Laranja

Exemplo Completo com List e Lambdas

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

public class Main {
    public static void main(String[] args) {
        List<String> nomes = new ArrayList<>(List.of("Ana", "Carlos", "João", "Maria"));

        // Exemplo de forEach
        nomes.forEach(nome -> System.out.println("Nome: " + nome));

        // Exemplo de removeIf
        nomes.removeIf(nome -> nome.startsWith("C"));
        System.out.println("Após removeIf: " + nomes);

        // Exemplo de replaceAll
        nomes.replaceAll(nome -> nome.toUpperCase());
        System.out.println("Após replaceAll: " + nomes);

        // Exemplo de stream com filter e map
        List<String> nomesFiltrados = nomes.stream()
                                           .filter(nome -> nome.length() > 3) // Filtra nomes com mais de 3 letras
                                           .map(nome -> "Olá, " + nome) // Adiciona uma saudação
                                           .toList();
        nomesFiltrados.forEach(System.out::println);
    }
}

Saida

Nome: Ana
Nome: Carlos
Nome: João
Nome: Maria
Após removeIf: [Ana, João, Maria]
Após replaceAll: [ANA, JOÃO, MARIA]
Olá, JOÃO
Olá, MARIA

Conclusão
A interface List combinada com lambdas facilita operações como iteração, modificação, filtro e transformação de dados. É uma ferramenta poderosa para manipulação sequencial em Java, permitindo código mais conciso, legível e declarativo.

1. List<E> (mais usada com lambdas)