Aulas

Prática de expressões lambda em coleções e no Stream API: como substituir classes anônimas por lambdas compactas, usar os métodos das coleções ( forEach, removeIf, sort, replaceAll) e construir pipelines de processamento de dados ( stream → filter → map → sorted → collect). Vamos comparar com classes anônimas, discutir variáveis “ final efetivamente” e apresentar uma tabela das operações principais, além de analisar erros comuns.

Na aula, analisamos por que o Java recebeu expressões lambda: concisão e legibilidade, passagem de comportamento como parâmetro, integração com coleções e a Stream API ( filter, map, forEach), captura de variáveis “efetivamente” final e uma forma prática de escrever callbacks com o operador ->. Em paralelo, veremos armadilhas: depuração de cadeias longas, ambiguidade em overloads ( Runnable vs Callable), limitações de closures, serialização e lambdas aninhadas. Ao final — recomendações práticas de quando usar lambdas e análise de erros típicos.

Nesta aula, vamos entender o que é um closure e como ele funciona em Java: como lambdas e classes anônimas “capturam” variáveis externas, por que variáveis locais devem ser final ou efetivamente final, em que a captura de variáveis locais difere do acesso a campos de classe, e como se comporta this em lambdas e classes anônimas. Vamos mostrar fábricas de funções com IntSupplier, analisar a implementação interna da captura e erros típicos (por exemplo, a mensagem do compilador Variable used in lambda expression should be final or effectively final).

Nesta aula explicamos o que é uma classe anônima em Java e em que ela difere de uma expressão lambda: sintaxe, possibilidades (campos, métodos adicionais, sobrescrita de toString/ equals), escopo e o comportamento de this, captura de variáveis (apenas final/“efetivamente final”). Mostramos exemplos práticos com Runnable, Comparator, Predicate, além de recomendações — quando escolher lambda e quando classe anônima.

Analisamos as interfaces funcionais essenciais do pacote java.util.function: Predicate, Consumer, Supplier, Function — o que recebem/devolvem e onde são usadas no Stream API ( filter, map, forEach, generate). Relembramos a regra “exatamente um método abstrato” e a anotação @FunctionalInterface, escrevemos lambdas, comparamos com classes anônimas, praticamos com a classe User e discutimos erros comuns na escolha entre Predicate/ Function etc.

Esta aula é sobre como montar pipelines de transformações a partir de funções pequenas usando Function e seus métodos compose e andThen. Vamos analisar a ordem de aplicação, a compatibilidade de tipos, exemplos com Predicate ( and, or, negate), Consumer ( andThen), construir pipelines práticos e discutir erros típicos: ordem trocada ( f.compose(g) vs f.andThen(g)), tipos incompatíveis e “código espaguete” em cadeias. Você vai aprender a aplicar apply, test, accept e a construir transformações legíveis e reutilizáveis.

Introdução prática à passagem de comportamento em Java: como usar expressões lambda ( ->) e referências a métodos ( ::) junto com a Stream API e coleções. Vamos analisar as interfaces funcionais padrão de java.util.function — Comparator, Predicate, Function, Consumer, Supplier — aprender a escrever métodos genéricos, aceitar comportamento como parâmetros e evitar erros típicos. Vamos praticar com exemplos usando Stream, Optional e utilitários próprios de processamento de listas.

Saindo de laços imperativos para pipelines declarativos de processamento de dados com a Stream API: entendendo operações intermediárias e terminais, avaliação preguiçosa, coleta de resultados via toList()/ collect, operações-chave map, filter, sorted, flatMap, reduce, além de verificações anyMatch/ allMatch/ noneMatch. Vamos comparar os estilos imperativo e funcional, analisar exemplos práticos e erros comuns, incluindo o uso inadequado de forEach ao montar coleções e o parallelStream() prematuro.

10 erros mais comuns ao trabalhar com lambdas e a Stream API em Java: captura de variáveis ( final/ effectively final), comportamento de this em lambdas, efeitos colaterais e paralelismo ( parallelStream()), inferência de tipos e generics, trabalho com null e Optional, composição de funções ( compose/ andThen) e também exceções checked (por exemplo, IOException). Mostramos práticas seguras: filtragem Objects::nonNull, operações terminais ( sum(), collect(...)), coleções seguras para threads e decomposição de cadeias longas.

Como o modelo de eventos é organizado em Java: a fonte gera um evento, e os ouvintes inscritos recebem a notificação e reagem. Vamos analisar as interfaces-chave de ouvintes do Swing — ActionListener, MouseListener, KeyListener, ChangeListener, DocumentListener — e mostrar como registrar manipuladores via addActionListener e implementar o método actionPerformed. Vamos praticar conectar ouvintes a JButton/ JFrame, comparar classes anônimas e expressões lambda, discutir erros típicos e dicas práticas.

Introdução prática e breve ao modelo de eventos do AWT/ Swing: criamos um botão JButton, registramos um ouvinte via addActionListener e tratamos em actionPerformed. Analisamos classes anônimas e expressões lambda, ouvintes populares ( MouseListener/ MouseAdapter, KeyAdapter, DocumentListener), escrevemos um miniaplicativo com JFrame, JButton, JLabel, observamos a sequência de chamadas e erros comuns (trabalho pesado no manipulador, variáveis finais em lambdas, addActionListener esquecido, remoção de ouvintes, uso de SwingWorker).

Nesta aula, veremos como projetar eventos personalizados em Java: criamos uma classe de evento baseada em java.util.EventObject, descrevemos a interface do ouvinte por meio de java.util.EventListener, adicionamos o mecanismo de inscrição/cancelamento ( add...Listener/ remove...Listener) e de notificação ( fire...). Veremos a prática com os exemplos de DataLoader e de um contador, discutiremos manipuladores em classes anônimas e expressões lambda, e também analisaremos erros típicos (exceções nos ouvintes, vazamentos de memória, ConcurrentModificationException).