Lessons

Practice of lambda expressions in collections and Stream API: how to replace anonymous classes with compact lambdas, use collection methods ( forEach, removeIf, sort, replaceAll) and build data-processing pipelines ( stream → filter → map → sorted → collect). We will compare them with anonymous classes, discuss “effectively final” variables, provide a table of the main operations, and analyse common pitfalls.

In this lecture, we discuss why Java gained lambda expressions: conciseness and readability, passing behavior as a parameter, integration with collections and the Stream API ( filter, map, forEach), capture of “effectively” final variables, and convenient callback syntax via the -> operator. In parallel, we’ll look at pitfalls: debugging long chains, overload ambiguity ( Runnable vs Callable), closure limitations, serialization, and nested lambdas. We conclude with practical recommendations on when to use lambdas and a review of common mistakes.

In this lecture, we break down what a closure is and how it works in Java: how lambdas and anonymous classes “capture” outer variables, why local variables must be final or effectively final, how capturing local variables differs from accessing class fields, and how this behaves in lambdas and anonymous classes. We’ll show function factories with IntSupplier, look into the internal capture implementation, and cover typical mistakes (for example, the compiler message Variable used in lambda expression should be final or effectively final).

In this lecture we unpack what an anonymous class is in Java and how it differs from a lambda expression: syntax, capabilities (fields, additional methods, overriding toString/ equals), scope and the behavior of this, variable capture (only final/“effectively final”). Practical examples with Runnable, Comparator, Predicate, plus recommendations — when to choose a lambda and when an anonymous class.

We break down the key functional interfaces from the java.util.function package: Predicate, Consumer, Supplier, Function—what they accept/return and where they are used in the Stream API ( filter, map, forEach, generate). We recall the “exactly one abstract method” rule and the @FunctionalInterface annotation, write lambdas, compare them with anonymous classes, practice with a User class example, and analyse common pitfalls when choosing between Predicate/ Function, etc.

This lecture is about building transformation pipelines from small functions using Function and its methods compose and andThen. We will cover execution order, type compatibility, examples with Predicate ( and, or, negate), Consumer ( andThen), build practical pipelines, and discuss common pitfalls: mixed-up order ( f.compose(g) vs f.andThen(g)), mismatched types, and “spaghetti” chains. You will learn to use apply, test, accept and to build readable, reusable transformations.

A practical introduction to passing behavior in Java: how to use lambda expressions ( ->) and method references ( ::) together with the Stream API and collections. We’ll cover the standard functional interfaces from java.util.function — Comparator, Predicate, Function, Consumer, Supplier — learn to write generic methods, accept behavior as parameters, and avoid common mistakes. We’ll practice with examples using Stream, Optional, and our own list-processing utilities.

We move from imperative loops to declarative data-processing pipelines with the Stream API: we cover intermediate and terminal operations, lazy evaluation, collecting results via toList()/ collect, the key operations map, filter, sorted, flatMap, reduce, as well as checks anyMatch/ allMatch/ noneMatch. We’ll compare imperative and functional styles, walk through practical examples, and cover common mistakes, including misusing forEach for collecting and premature parallelStream().

The 10 most common mistakes when working with lambdas and the Stream API in Java: variable capture ( final/ effectively final), the behavior of this in lambdas, side effects and parallelism ( parallelStream()), type inference and generics, working with null and Optional, function composition ( compose/ andThen), as well as checked exceptions (for example, IOException). We show safe practices: filtering with Objects::nonNull, terminal operations ( sum(), collect(...)), thread-safe collections, and decomposing long chains.

How the event model works in Java: a source generates an event, and subscribed listeners receive a notification and react. We will examine the key Swing listener interfaces — ActionListener, MouseListener, KeyListener, ChangeListener, DocumentListener — and show how to register handlers via addActionListener and implement the actionPerformed method. We will practice attaching listeners to JButton/ JFrame, compare anonymous classes and lambda expressions, and discuss common mistakes and practical tips.

A brief hands-on introduction to the AWT/ Swing event model: we create a JButton, register a listener via addActionListener, and handle it in actionPerformed. We examine anonymous classes and lambda expressions, popular listeners ( MouseListener/ MouseAdapter, KeyAdapter, DocumentListener), build a mini application based on JFrame, JButton, JLabel, look at the call sequence and common mistakes (heavy work in a handler, variable finality in lambdas, a forgotten addActionListener, removing listeners, using SwingWorker).

In this lecture, we examine how to design custom events in Java: create an event class based on java.util.EventObject, define a listener interface via java.util.EventListener, add a subscribe/unsubscribe mechanism ( add...Listener/ remove...Listener) and notifications ( fire...). We’ll look at practical examples with DataLoader and a counter, discuss handlers with anonymous classes and lambda expressions, and also cover common mistakes (exceptions in listeners, memory leaks, ConcurrentModificationException).