Key Concepts

Primitive streams like IntStream avoid boxing when you sum or average numbers. A stream can be consumed only once, and a plain for loop is still the clearer choice for simple iteration or early exits.

Optional

Optional<T> puts the possibility of "no value" into the type. It is meant mostly for return values, so callers are pushed to handle the empty case. Prefer map, orElse, orElseThrow, and ifPresent over calling get() blindly.

import java.util.Optional;

static Optional<Employee> findByName(List<Employee> list, String name) {
    return list.stream()
            .filter(e -> e.name().equals(name))
            .findFirst();
}

String team = findByName(staff, "Lee")
        .map(Employee::team)
        .orElse("unknown"); // dev

findByName(staff, "Choi").ifPresentOrElse(
        e -> System.out.println(e.team()),
        () -> System.out.println("not found"));

Employee lee = findByName(staff, "Lee")
        .orElseThrow(() -> new IllegalStateException("Lee missing"));

Avoid Optional for fields, parameters, and collection elements; an empty collection already means "nothing here".

Concurrency basics

Java has had threads since the beginning, but you rarely create them yourself. Submit tasks to an ExecutorService instead: submit returns a Future, and get() blocks until its result is ready.

import java.util.*;
import java.util.concurrent.*;

static int slowSquare(int n) throws InterruptedException {
    Thread.sleep(100); // simulate slow work
    return n * n;
}

public static void main(String[] args) throws Exception {
    try (ExecutorService pool = Executors.newFixedThreadPool(4)) {
        List<Future<Integer>> futures = new ArrayList<>();
        for (int i = 1; i <= 5; i++) {
            int n = i;
            futures.add(pool.submit(() -> slowSquare(n)));
        }
        int sum = 0;
        for (Future<Integer> f : futures) sum += f.get();
        System.out.println("sum = " + sum); // 55
    } // close() waits for running tasks, then shuts down
}

Recent JDKs add virtual threads: lightweight threads scheduled by the JVM, cheap enough to use one per task. They suit servers that mostly wait on I/O, and the code stays ordinary blocking code; only the executor changes.

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10_000; i++) {
        int id = i;
        executor.submit(() -> {
            Thread.sleep(50); // blocking is cheap here
            return id;
        });
    }
}

When threads share mutable data, use thread-safe types such as ConcurrentHashMap and AtomicInteger, or guard access with synchronized. Sharing immutable records avoids most such problems.

Summary

• Lambdas and method references implement functional interfaces concisely.
• Streams transform data declaratively with filter, map, and collect.
• Optional marks a possibly missing return value; unwrap it with map or orElse.
• Give concurrent work to an ExecutorService, and consider virtual threads for I/O-heavy workloads.

Official resources for going further:

• Learn Java (dev.java): the official learning path
• Java SE Documentation: API references and tool guides
• The Java Language Specification: the formal specification
• OpenJDK: JDK development and JEPs
• JUnit User Guide: the testing framework
• Maven and Gradle: build tools