Java 8+

List<String> filePaths = List.of("a.txt", "b.txt");
// Catching and re-throwing as unchecked exception inside lambda:
List<String> contents = filePaths.stream()
    .map(path -> {
        try { return Files.readString(Path.of(path)); }
        catch (IOException e) { throw new UncheckedIOException(e); }
    })
    .toList();

// Attaching annotations to inferred lambda parameters:
BiFunction<String, String, String> concat = (@Nonnull var a, @Nonnull var b) -> a + b;

Set<String> set = Set.of("X", "Y", "Z"); // Unordered
Optional<String> first = set.stream().findFirst(); // Any element (no encounter order)

interface UserFactory {
    User create(String name, int age);
}
class User {
    public User(String name, int age) {}
}
// Method reference implementation of factory:
UserFactory factory = User::new;
User u = factory.create("Alice", 25);

record Author(String genre, List<String> books) {}
List<Author> authors = getAuthors();
// Groups all unique book titles by genre:
Map<String, Set<String>> booksByGenre = authors.stream()
    .collect(Collectors.groupingBy(
        Author::genre,
        Collectors.flatMapping(a -> a.books().stream(), Collectors.toSet())
    ));

List<Integer> smallList = List.of(1, 2, 3, 4, 5);
// Sequential is faster for small lists:
int sum = smallList.stream().mapToInt(i -> i * 2).sum();

record Student(String grade, String name) {}
List<Student> students = getStudents();
// Groups by grade and extracts only names into a List<String>:
Map<String, List<String>> namesByGrade = students.stream()
    .collect(Collectors.groupingBy(Student::grade, Collectors.mapping(Student::name, Collectors.toList())));

Optional<User> user = findInCache(id)
    .or(() -> findInDatabase(id))
    .or(() -> findInRemoteService(id));

IntBinaryOperator primitiveAdd = (a, b) -> a + b; // Zero heap allocation
BinaryOperator<Integer> boxedAdd = (a, b) -> a + b; // Autoboxing overhead

// Equivalent to for (int i = 0; i < 10; i += 2)
Stream.iterate(0, i -> i < 10, i -> i + 2)
    .forEach(System.out::println);

// Inefficient reduce (creates new string every step):
// stream.reduce("", (s1, s2) -> s1 + s2);

// Efficient mutable collect (single container):
String res = Stream.of("a", "b", "c").collect(Collectors.joining());

Set<String> set = Set.of("A", "B");
// Spliterator reports DISTINCT | SIZED
Spliterator<String> sp = set.spliterator();
boolean isDistinct = sp.hasCharacteristics(Spliterator.DISTINCT); // true

List<Integer> list = List.of(3, 1, 4, 1, 5);
List<Integer> sorted = list.stream().sorted(Comparator.naturalOrder()).toList(); // [1, 1, 3, 4, 5]

record Transaction(int[] amounts) {}
List<Transaction> txs = getTransactions();
int sum = txs.stream()
    .mapMultiToInt((tx, sink) -> { for (int a : tx.amounts()) sink.accept(a); })
    .sum();

Stream<String> stream = List.of("A", "B").stream();
stream.forEach(System.out::println); // Consumes stream
// stream.count(); // Throws IllegalStateException: stream has already been operated upon or closed

List<String> list = Arrays.asList("Banana", null, "Apple", null);
list.sort(Comparator.nullsLast(String::compareTo));
// Result: ["Apple", "Banana", null, null]

List<Integer> list = List.of(2, 4, 5, 8, 10, 11);
// Drops 2, 4. As soon as 5 fails predicate, rest (8, 10, 11) are included:
List<Integer> res = list.stream().dropWhile(n -> n % 2 == 0).toList(); // [5, 8, 10, 11]

Map<String, Integer> scores = Map.of("Alice", 95, "Bob", 88);
// BiConsumer iteration over Map entries:
scores.forEach((name, score) -> System.out.println(name + " scored: " + score));

// Diamond with anonymous inner class (Java 9+):
Consumer<List<String>> consumer = new Consumer<>() {
    public void accept(List<String> list) { list.clear(); }
};

record Employee(String dept, int salary) {}
List<Employee> list = getEmployees();
// Retains all department keys, even if no employee has salary > 5000:
Map<String, Set<Employee>> result = list.stream().collect(
    Collectors.groupingBy(Employee::dept, Collectors.filtering(e -> e.salary() > 5000, Collectors.toSet()))
);

record Order(List<Integer> itemPrices) {}
List<Order> orders = getOrders();
// flatMapToInt flattens directly to IntStream:
int grandTotal = orders.stream()
    .flatMapToInt(o -> o.itemPrices().stream().mapToInt(Integer::intValue))
    .sum();

IntStream stream = IntStream.of(10, 20, 30);
OptionalDouble avg = stream.average();
if (avg.isPresent()) {
    System.out.println("Average: " + avg.getAsDouble());
}

List<Integer> list = List.of(5, 3, 9, 1);
Optional<Integer> first = list.stream().findFirst(); // Returns 5 (short-circuits)
Optional<Integer> min = list.stream().min(Integer::compareTo); // Returns 1 (traverses all)

List<String> words = List.of("apple", "banana", "kiwi");
IntSummaryStatistics stats = words.stream()
    .collect(Collectors.summarizingInt(String::length));

System.out.println("Count: " + stats.getCount());
System.out.println("Max: " + stats.getMax());
System.out.println("Avg: " + stats.getAverage());

interface MathService {
    static double add(double a, double b) { return a + b; }
    default double multiply(double a, double b) { return a * b; }
}
// Static: MathService.add(5, 3)
// Default: new MyService().multiply(5, 3)

// Required: I/O backed stream must be closed via try-with-resources
try (Stream<String> lines = Files.lines(Path.of("data.txt"))) {
    lines.filter(s -> s.contains("ERROR"))
         .forEach(System.out::println);
}

List<Integer> list = List.of(1, 2, 3, 4, 5, 2, 3);
// Eliminates ordering constraints for faster parallel deduplication:
List<Integer> unique = list.parallelStream()
    .unordered()
    .distinct()
    .toList();

List<String> items = List.of("alpha", "beta", "gamma");
// Optimized for parallel execution:
Optional<String> match = items.parallelStream()
    .filter(s -> s.contains("a"))
    .findAny();

List<String> list = List.of("a", "b", "c");
// Fast O(1) count without invoking toUpperCase() transformation:
long count = list.stream().map(String::toUpperCase).count();

class Memoizer {
    private static final Map<Integer, Long> cache = new ConcurrentHashMap<>();
    public static long fib(int n) {
        if (n <= 1) return n;
        return cache.computeIfAbsent(n, key -> fib(key - 1) + fib(key - 2));
    }
}