Java – Updates, How-Tos, and Tutorials

Latest Articles

Java Stream reduce() (with Examples)

October 2, 2026Java Stream reduce() explained: the three variants, identity and combiner, parallel streams, and when to use collect() instead.

Java Functional Interfaces (with Examples)

September 28, 2026Java functional interfaces explained from the ground up: the rule, @FunctionalInterface, all 43 interfaces in java.util.function, and when to write your own.

Java Optional (with Examples)

September 25, 2026Java Optional explained with examples: of() and ofNullable(), orElse() vs. orElseGet(), map() and flatMap(), when to use Optional, and what Valhalla changes.

Java Lambda Expressions (with Examples)

September 23, 2026Java lambda expressions explained from the ground up: syntax, target types, effectively final, method references, and how the JVM runs them.

Java Basics + Data Structures

This category covers core Java functionality, such as String processing, object conversion, and random number generation, as well as data structures, such as collections, maps and sets, trees, queues, deques, and stacks.

How to Declare and Initialize Arrays in Java

How to declare and initialize arrays in Java, fill and copy them, and convert lists, sets, and streams into arrays – including 2D arrays.

Java Array Length and Size: .length, 2D Arrays, Max Array Size

How to get and set the length of a Java array, including 2D arrays – plus an array’s memory use in Java 27 and the maximum array size.

Java main() Method – Syntax and Simplification Since Java 25

What does public static void main(String[] args) mean? The main() method, step by step – and why void main() is enough since Java 25.

Generating Random Numbers in Java – and Predicting Them

Random numbers in Java: Math.random(), Random, ThreadLocalRandom, and SecureRandom – and why pseudorandom numbers can be predicted.

compareTo, Comparable, Comparator – Comparing Objects in Java

How to compare objects in Java: Comparable and compareTo() define the natural order, Comparator.comparing() any other – with examples.

Java substring() Method

How to use Java’s String.substring() method? How does substring() work internally, and how has the implementation changed over time?

Project Amber – Java Syntax Enhancements

In Project Amber, new Java language features are being developed such as switch expressions, text blocks, records, pattern matching, and sealed classes.

Java Switch Expressions (JEP 361): Arrows, yield, No break

Switch expressions since Java 14 (JEP 361): arrow cases without break, values via yield, exhaustiveness for enums – and what Java 21 added.

Java Text Blocks

Text blocks are a notation for multiline strings in Java. Why do we need them? How to write and format them? Which escape sequences must we use?

Java Records: The Complete Guide (with Examples)

What are Java records? Why do we need them? How do you implement and use them? And what about inheritance, reflection, and serialization?

Sealed Classes and Interfaces in Java

Sealed classes and interfaces in Java: sealed, permits, and non-sealed – and how the compiler uses them to check switch exhaustiveness.

Unnamed Variables and Patterns in Java

With the underscore (_), you can mark variables and patterns in Java that you don’t need – making your code more concise. Learn what to watch out for.

String Templates in Java

String templates were withdrawn after two previews (Java 21/22): how they worked, why the design was pulled, and what the alternatives are.

Flexible Constructor Bodies in Java 25: Executing Code Before super()

Flexible Constructor Bodies: Since Java 25, you can run code before super(...) and this(...) in constructors. This article shows you how.

import module in Java: Module Import Declarations

Since Java 25, “import module” imports entire modules instead of individual classes. In JShell + Compact Source Files, “java.base” is included by default.

Primitive Types in Patterns, instanceof, and switch (Java)

Primitive type patterns bring primitive types into pattern matching. Learn how to use them with instanceof and switch starting in Java 23 + examples.

Withers in Java: Derived Record Creation Expressions (Preview)

Withers (Derived Record Creation Expressions) derive new Java records by specifying only the changed components — no boilerplate.

Java versions cheat sheet – stacked PDF pages

Free PDF:

Your Java Versions Cheat Sheet

All features from Java 10 to Java 27 – one page per version

Get the compact overview of all Java versions. You’ll instantly know which updates are worth adopting in your project – and see at a glance which Java version introduced a specific feature.

You get access to this PDF collection by signing up for my newsletter. You can opt-out at any time.

Advanced Java Topics

This section covers advanced Java topics such as reflection, concurrency, garbage collection, and the Java memory model.

Java Virtual Threads (JEP 444): How They Work, Examples, Pitfalls

Virtual threads in Java (Project Loom): how they work and how to handle millions of blocking tasks without async code – with examples.

Lazy Constants in Java (Stable Values) – Safe and Lazy Initialization

What are Lazy Constants (formerly Stable Values), and how do you use them? What are Lazy Lists and Lazy Maps? How do they work internally?

Structured Concurrency in Java 27 with StructuredTaskScope

Structured Concurrency in Java 27: how StructuredTaskScope forks subtasks, cancels them, and propagates errors – with a custom joiner.

Double-Checked Locking in Java – Thread-Safe and Correct

Learn how to implement Double-Checked Locking in Java the correct, thread-safe way – for lazy object initialization without full synchronization.

Java Scoped Values (JEP 506) Explained – vs. ThreadLocal

Scoped Values (JEP 506) replace ThreadLocal since Java 25: binding, rebinding, child-thread inheritance – and where ThreadLocal falls short.

Initialization-on-Demand Holder Idiom in Java

Learn how the Initialization-on-Demand Holder Idiom in Java enables thread-safe lazy initialization of static fields without synchronization overhead.

Java FFM API (JEP 454): Foreign Function & Memory API Tutorial

Learn how to use the FFM API (Project Panama) to call native libraries from Java and access native memory – without JNI.

Java Object Headers and Compressed Class Pointers

How is a Java object header structured? You’ll learn about Mark Word, Class Word, Compressed Class Space, and Compressed Class Pointers in detail.

Compressed Oops in Java: How 32-Bit References Save Memory

Compressed Oops represent Java object references on 64-bit systems with just 32 instead of 64 bits, reducing memory usage. Here’s how it works.

Compact Object Headers in Java (JEP 519) – default since Java 27

How Java shrinks object headers from 96 to 64 bits without losing information. Compact Object Headers (JEP 519), default since Java 27.

Ahead-of-Time Class Loading & Linking: Java’s AOT Cache

Ahead-of-Time Class Loading & Linking speeds up Java application startup by up to 42%. Here’s how to create the AOT cache, step by step.

Java ByteBuffer Explained: position, limit, flip(), compact()

Java’s ByteBuffer step by step: position, limit, and capacity, put() and get(), flip() and compact() – with a diagram for every step.

Java Deep Reflection: How to Hack Integer and String

In Java: can 2+3 = 6? How can Deep Reflection be used to change the values of Integers and Strings at runtime?

New Java Features

Every new Java release brings big and small changes:

Changes to the language itself (lambdas, the module system, var, improvements from Project Amber, ...),
API enhancements and
Performance improvements under the hood.

In addition, legacy features are regularly marked as “deprecated”, then as “deprecated for removal”, and later completely removed from the JDK.

In this series of articles, you will learn everything about the most important changes in each Java release.

Java 9 Features (with Examples)

All Java 9 features with examples: module system, jshell, List.of(), private interface methods, Flow API, Stack-Walking API, Process API, and more.

Java 10 Features (with Examples)

All new features of Java 10 with examples: “var”, Immutable Collections, Optional.orElseThrow(), Application Class-Data Sharing, and more.

Java 11 Features (with Examples)

All new features of Java 11 with examples: “var” in Lambdas, HttpClient, new String, Files, and Path methods, Epsilon GC, Flight Recorder, and more.

Java 12 Features (with Examples)

All new features of Java 12 with examples: new String and Files methods, Teeing Collector, Default CDS Archives, G1 optimizations, and more...

Java 13 Features (with Examples)

All new features of Java 13 with examples: Switch Expressions with yield, Text Blocks, Dynamic CDS Archives, Soft Max Heap Size, and more.

Java 14 Features (with Examples)

Java 14 features with examples: Switch Expressions, Helpful NullPointerExceptions, Previews: Records + Pattern matching for instanceof + more.

Java 15 Features (with Examples)

All the new features of Java 15 with examples: Text Blocks, ZGC + Shenandoah, new String methods, Sealed Classes (preview), and more...

Java 16 Features (with Examples)

Java 16 Features with examples: Records, “Pattern Matching for instanceof”, Stream.toList(), jpackage, Strong Encapsulation, and more.

Java 17 Features (with Examples)

Java 17 features (LTS) with examples: Sealed Classes, InstantSource, HexFormat, context-specific deserialization filters, and more.

Java 18 Features (with Examples)

Java 18 features with examples: UTF-8 by default, jwebserver, the @snippet tag in JavaDoc, Internet-Address Resolution SPI, and more.

Java 19 Features: Virtual Threads, Record Patterns and More

The new Java 19 features with examples: Virtual Threads (preview), Record Patterns (preview), Foreign Function & Memory API (preview) + more

Java 20 Features (with Examples)

The new Java 20 features with examples: Scoped Values, Record Patterns, Pattern Matching for switch, Virtual Threads, Structured Concurrency

Java 21 Features (with Examples)

All Java 21 features with examples: virtual threads, sequenced collections, record patterns, pattern matching for switch, and more.

Java 22 Features (with Examples)

Java 22 features with examples: Foreign Function & Memory API, unnamed variables & patterns, multi-file programs, Stream Gatherers + more.

Java 23 Features (with Examples)

All Java 23 features with examples: primitive type patterns, Markdown in JavaDoc, import modules, init fields in the constructor before super() + more!

Java 24 Features (with Examples)

Java 24 with code examples: Stream Gatherers, synchronized in virtual threads without pinning, AOT Class Loading, Compact Object Headers.

Java 25 Features (with Examples)

Java 25 (LTS): Scoped Values, Compact Source Files, Flexible Constructor Bodies, Compact Object Headers, and more – explained with examples.

Java 26 Features (with Examples)

Java 26 features (March 2026) with examples: HTTP/3, Lazy Constants, AOT caching with any GC, “final means final”, a faster G1, and more.

Java 27 Features (with Examples)

Java 27 explained – with code examples: Compact Object Headers by default, G1 everywhere, quantum-safe TLS, Lazy Sets and more.

How to Change Java Versions in Windows (updated for Java 28)

How to install multiple Java versions on Windows in parallel? How to change Java versions on the command line? (Up to JDK 28)

Java Modernization: How to Get Your Team and Management on Board

How to get your team and management excited about Java modernization – with clear arguments, practical examples & quick wins for sustainable success.

Article Series “Files in Java”

What you’ll learn:

How to read and write text and binary files
Character encoding and line breaks
Constructing relative and absolute file and directory names with File, Path, and Paths
How to list all files of a directory, how to search files
How to move, rename, copy and delete files
Saving complex objects and primitive data types in binary files
Writing and reading files with FileChannel and ByteBuffer

How to Read a File in Java – to String, Byte Array, or Line by Line

Read a file in Java – into a string, a byte array, or line by line: Files, FileReader and BufferedReader compared, plus character encoding.

Java Write to File: Files.writeString(), FileWriter, BufferedWriter

How to write a string, lines, or a byte array to a file in Java: Files, FileWriter, BufferedWriter – and when buffering pays off.

File and Directory Names in Java: File, Path, Paths

Filename, directory name, path – what’s the difference? How to build file paths in Java with File, Path, and Paths, independent of the OS.

How to List, Move, Copy, and Delete Files (Java Files Tutorial)

How to list all files in a directory (recursively) in Java? How to move, copy and delete files? How to create a symbolic link with Java?

DataOutputStream + DataInputStream (Java Files Tutorial)

How to write primitive data types (int, long, char, ...) to files and how to read them back? DataOutputStream, DataInputStream.

Java FileChannel: Read, Write, Memory-Mapped Files, Locks

Read and write files with FileChannel and ByteBuffer, memory-map them (also beyond 2 GB), and lock file regions – with a speed comparison.

Java Performance

This category deals with the performance of Java code, i.e., with which Java means a particular task can be executed most efficiently - possibly depending on the Java version. Not only is it important to know how to optimize code, but also when it is better to leave the optimization to the Java Runtime and the Hotspot Compiler.

How to Convert int to String in Java – Which Way Is Fastest?

Convert int to String in Java: four variants benchmarked with JMH on Java 8 to 27. Which one is fastest – and why it hardly matters today.

How to Convert String to Int in Java – Peculiarities and Pitfalls

How to convert a String to an int in Java? Pitfalls, parseInt() vs. parseUnsignedInt(), int vs. Integer – with benchmarks up to Java 27.

Want Even More Knowledge?

My blog features many articles on Java, software architecture, and performance — from foundational concepts to advanced patterns.

If you want to go deeper, check out my trainings: hands-on, easy to understand, and directly applicable to your day-to-day project work. Instead of theory, I teach principles that help you write code that is better, more maintainable, and more performant in the long run.

Explore the Java Trainings