Aulas

Nesta aula, aprendemos a agrupar dados em streams com os coletores Collectors.groupingBy e Collectors.partitioningBy: agrupamento simples e aninhado, divisão por critério booleano, escolha entre eles, processamento do resultado e dicas. Em exemplos práticos com strings, números e objetos, você verá como obter um Map com a estrutura desejada a partir de um fluxo ( Stream API) e como trabalhar com funções-classificadoras ( Function) e predicados ( Predicate). No fim — análise de erros típicos.

Imersão prática em agrupamentos aninhados com Stream e coletores: como combinar Collectors.groupingBy com agregadores ( maxBy, averagingInt, counting), transformar dados com mapping, dividir em subconjuntos via partitioningBy e ler corretamente estruturas Map aninhadas. Muitos exemplos ilustrativos, visualização da estrutura dos resultados e análise de erros comuns.

Nesta aula, analisamos técnicas avançadas com coletores do Stream API: coletores downstream aninhados para groupingBy/ partitioningBy, transformações com mapping, filtragem com filtering, “desdobramento” com flatMapping, agregação simultânea com teeing (Java 12+), bem como “congelamento” de coleções via toUnmodifiableList/Set/Map e collectingAndThen. Mostramos pipelines práticos e erros comuns.

Nesta aula vamos entender a diferença entre transformar dados com map, o “achatamento” com flatMap e o análogo mais eficiente a partir do Java 16+ — mapMulti. Em exemplos práticos veremos como “desempacotar” coleções aninhadas para o formato Stream<String> em vez de Stream<Stream<String>>, como trabalhar com Optional via stream(), e também quando escolher mapMulti em nome do desempenho, evitando a criação de fluxos intermediários.

Nesta aula, analisamos maneiras de unir dados no Stream API: o método estático Stream.concat para dois streams, a combinação de Stream.of + flatMap para um número arbitrário de streams, e o collector Collectors.joining para colar elementos em uma única string. Vamos falar sobre avaliação preguiçosa (lazy), uso único dos streams, preservação da ordem e erros típicos (reutilização do stream, streams infinitos, joining para não-strings) — com exemplos práticos.

Nesta aula, analisamos operações típicas sobre conjuntos em Java: união ( union), interseção ( intersection) e diferença ( difference) com base na interface Set e na Stream API. São mostrados exemplos práticos com Stream.concat, Stream.of + flatMap, alternativas via retainAll/ removeAll, bem como nuances importantes sobre equals/ hashCode, desempenho e erros comuns.

Nesta aula, vamos entender o que é zip e por que ele não existe no Stream API padrão (até Java 22), aprender a “costurar” coleções pelos índices com IntStream.range e também criar streams “na hora” usando Stream.iterate e Stream.generate. Exemplos, visualizações e erros comuns ajudarão você a aplicar com segurança geração e zip nas tarefas.

Guia detalhado sobre erros frequentes ao trabalhar com a API Stream em Java: natureza de uso único do stream e repetição de operações terminais ( collect(), forEach(), count()), modificação da coleção durante a iteração, limit() esquecido em streams infinitos ( iterate, generate), tratamento de null e uso de Optional com flatMap(Optional::stream), preservação de ordem com forEachOrdered(), operações de conjunto eficientes com Set, fechamento correto de recursos ( Files.lines + try-with-resources), cautela com parallelStream() e o princípio “enquanto não houver operador terminal — nada é executado”. Todos os problemas são acompanhados de exemplos claros e correções.

Nesta aula, vamos entender por que os streams “normais” de coleções de números ( Stream<Integer>, Stream<Double>) podem ser ineficientes por causa do boxing/unboxing e como os streams primitivos — IntStream, LongStream, DoubleStream — ajudam a evitar isso. Veremos conversões mapToInt/ boxed(), operações de agregação ( sum(), average(), summaryStatistics()), resultados seguros com OptionalInt/ OptionalDouble, além de onde a otimização realmente traz ganho e como medir o efeito com o JMH.

Nesta aula, analisamos como funciona o processamento preguiçoso no Stream API: em que os operadores intermediários e terminais diferem, por que os cálculos começam apenas após a chamada de um terminal, e quais vantagens oferecem o processamento elemento a elemento e as “operações de curto-circuito”. Vamos mostrar cadeias com filter, map, peek, findFirst, forEach, visualizar a passagem dos elementos e discutir erros típicos e recomendações sobre a ordem eficiente das operações.

Nesta aula, analisamos como proteger dados usando os wrappers imutáveis Collections.unmodifiableList, unmodifiableSet, unmodifiableMap, qual é a diferença entre imutabilidade “superficial” e “profunda”, quando e por que retornar wrappers a partir de métodos, bem como alternativas modernas List.of/ Set.of/ Map.of. Falaremos sobre erros típicos (por exemplo, esperar imutabilidade profunda ou trabalhar com null) e por que tentativas de modificação resultam em UnsupportedOperationException.

Na aula, analisamos o que é o Spliterator, como ele permite não apenas iterar sobre elementos, mas também dividir a fonte de dados em partes com trySplit(), como os streams paralelos funcionam a partir disso via parallelStream() e o pool comum ForkJoinPool. São mostrados os métodos-chave ( tryAdvance, estimateSize, characteristics), características típicas ( ORDERED, SIZED, CONCURRENT e outros), exemplos práticos, um diagrama Mermaid e erros comuns ao usar streams paralelos.