Lessons

This lecture explains how to write custom collectors for the Stream API with Collector and when it is truly justified, as well as how to implement your own Spliterator for efficient sequential and parallel data traversal. We will step through the collector components ( supplier, accumulator, combiner, finisher, characteristics), examples for multi-maps and top-N, trySplit strategies, and the correct setup of characteristics ( ORDERED, SIZED, SUBSIZED, etc.).

In this lecture we examine immutable collections in Java 9+: the factory methods List.of, Set.of, Map.of and Map.ofEntries. We will compare them with the wrappers Collections.unmodifiableList, discuss limitations (no mutations, no null, no duplicates for a set and for map keys), element order, and performance. We will look at the limit of 10 pairs for Map.of and typical exceptions: UnsupportedOperationException, NullPointerException, IllegalArgumentException. Plus practical examples of when such collections simplify design and improve read-side thread safety.

In this lecture we cover immutable copies of collections introduced in Java 10: List.copyOf, Set.copyOf and Map.copyOf. You will learn how they differ from the Collections.unmodifiable* wrappers, what constraints apply (no null, immutability), when the same object is returned, and why you must not rely on a specific implementation. Practical usage scenarios and typical mistakes are shown, including confusion with Map.of and Map.ofEntries.

In this lecture, we examine two approaches to “protecting” collections: unmodifiable wrappers from Collections.unmodifiable* and the factory methods List.of/ Set.of/ Map.of, as well as the thread-safe CopyOnWriteArrayList and CopyOnWriteArraySet from the java.util.concurrent package. We will understand how a wrapper differs from true immutability, where CopyOnWrite structures are useful, and what typical mistakes occur in practice.

In this lecture, we break down the differences between mutable and immutable collections in Java: when to choose ArrayList/ HashSet and when to prefer Java 9+ factory methods ( List.of, Set.of, Map.of) and copies via copyOf. We will discuss safety, thread safety, ease of debugging, pitfalls of the Collections.unmodifiableList wrapper and practical usage examples, as well as common mistakes and how to avoid them.

In Java 21, ordered-collection interfaces appeared — SequencedCollection, SequencedSet, and SequencedMap. They add a unified contract for working with element order: fast access to the first/last element and reversing a collection via reversed(). In this lecture, we will examine which standard collections already implement them, what methods were added, how to apply this in real code, as well as common mistakes and usage nuances.

This lecture is a brief guide to the evolution of file I/O in Java: from the “classic” java.io package with the File class, FileInputStream/ FileOutputStream streams, and character-based Reader/ Writer to modern java.nio.file (NIO.2) with Path, Files, and FileSystem. We’ll examine how the approaches differ, where asynchronous I/O shines, how to migrate safely ( File . toPath() ⇄ Path . toFile()), and also look at practical examples, a quick reference for choosing an API, and common mistakes.

In this lecture, we break down three key entities of Java’s file API: the historical File, the modern path abstraction Path from NIO.2, and the utility “Swiss Army knife” class Files. In practice, we’ll see how to create objects, convert File ↔ Path, safely join paths via resolve, obtain relative paths via relativize, normalize them with normalize, and perform operations such as Files.exists, Files.copy, Files.move, Files.readAllLines/ Files.write. The result is a clear understanding of when to use each approach and which mistakes are most common.

In this lecture, we look at quick ways to work with files using the java.nio.file.Files utilities: read the entire file ( readAllBytes, readAllLines) and write data ( write) with an explicit charset StandardCharsets.UTF_8. We’ll discuss handling IOException, show practical examples, talk about when you need streaming APIs ( BufferedReader, BufferedWriter), and break down common mistakes.

In this lecture, we examine file modes in Java: overwrite and append, combinations of StandardOpenOption options (for example, APPEND, CREATE, TRUNCATE_EXISTING, CREATE_NEW), working with text and bytes via Files.write()/ Files.readAllBytes(), when to choose streams ( BufferedReader/ BufferedWriter), and how to properly handle exceptions ( IOException, etc.). Plenty of practical examples and a breakdown of common mistakes.

A practical lecture on working with the file system via java.nio.file: create directories with Files.createDirectory and Files.createDirectories, delete via Files.delete and Files.deleteIfExists, list contents with Files.list, and cover recursive deletion with Files.walkFileTree. Step-by-step examples, a mini file manager, and a section on common mistakes will help you work confidently with folders on any OS.

Why reading and writing files “with a teaspoon” is expensive: we’ll break down how buffering speeds up text I/O in Java. We’ll see how BufferedReader and BufferedWriter work on top of FileReader/ FileWriter, use line-by-line reading via readLine(), writing and newline via write()/ newLine(), explicit flushing with flush(), set the buffer size, and deal with encodings via InputStreamReader/ OutputStreamWriter. When to apply buffering, when not — and which mistakes happen most often.