Java

// Checked: wywołujący MUSI obsłużyć lub zadeklarować
void readConfig(String path) throws IOException {
    Files.readString(Path.of(path));
}

// Unchecked: wywołujący MOŻE obsłużyć, kompilator nie wymusza
int divide(int a, int b) {
    if (b == 0) throw new IllegalArgumentException("Divisor cannot be zero");
    return a / b;
}

static void readFirstLine(Path path) throws IOException {
    try (BufferedReader reader = Files.newBufferedReader(path)) {
        System.out.println(reader.readLine());
    }
}

final class Point {
    private final int x, y;

    Point(int x, int y) { this.x = x; this.y = y; }

    @Override
    public boolean equals(Object o) {
        return o instanceof Point p && x == p.x && y == p.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }
}

Integer a = 127, b = 127;
System.out.println(a == b); // true, cache -128..127

Integer c = 128, d = 128;
System.out.println(c == d); // false, poza cache, różne obiekty

System.out.println(c.equals(d)); // true, poprawne porównanie wartości

String a = "Tenzan";
String b = "Tenzan";
System.out.println(a == b); // true, ten sam obiekt z string pool

String c = new String("Tenzan");
System.out.println(a == c);          // false, nowy obiekt na stercie
System.out.println(a == c.intern()); // true, intern() zwraca referencję z puli

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i).append(',');
}
String result = sb.toString();

public record Employee(String name, String email, double salary) {}

Employee e = new Employee("Anna Kowalska", "anna@firma.pl", 9500.0);
System.out.println(e.name()); // "Anna Kowalska", brak prefiksu "get"
System.out.println(e);        // Employee[name=Anna Kowalska, email=anna@firma.pl, salary=9500.0]

public record Range(int min, int max) {
    public Range {
        if (min > max) {
            throw new IllegalArgumentException("min > max");
        }
        // brak this.min = min: przypisanie pól jest niejawne
    }
}

public interface PaymentProcessor {
    void charge(double amount);

    default void chargeWithLog(double amount) {
        log(amount);
        charge(amount);
    }

    private void log(double amount) {
        System.out.printf("Charging %.2f%n", amount);
    }
}

public sealed interface Shape permits Circle, Square, Triangle {}

public record Circle(double radius) implements Shape {}
public record Square(double side) implements Shape {}
public record Triangle(double base, double height) implements Shape {}

static double area(Shape shape) {
    return switch (shape) {
        case Circle c -> Math.PI * c.radius() * c.radius();
        case Square s -> s.side() * s.side();
        case Triangle t -> t.base() * t.height() / 2;
    };
}

record Point(int x, int y) {}

static String describe(Object obj) {
    return switch (obj) {
        case Point(int x, int y) when x == y -> "Punkt na przekątnej: " + x;
        case Point(int x, int y) -> "Punkt (" + x + ", " + y + ")";
        default -> "Nieznany obiekt";
    };
}

static <T extends Comparable<T>> T max(List<T> list) {
    return list.stream()
        .max(Comparator.naturalOrder())
        .orElseThrow(NoSuchElementException::new);
}

static void copy(List<? extends Number> source, List<? super Number> destination) {
    for (Number n : source) {
        destination.add(n);
    }
}

var users = new ArrayList<String>();  // typ: ArrayList<String>
for (var user : users) {              // typ: String
    System.out.println(user.toUpperCase());
}

try (var conn = dataSource.getConnection()) {
    // typ: Connection
}

List<String> names = List.of("Ala", "Bartek", "Celina");

names.stream()
    .filter(n -> {
        System.out.println("filter: " + n);
        return n.length() > 3;
    })
    .map(String::toUpperCase);
// brak wypisania na konsolę - bez operacji terminalnej pipeline się nie wykonuje

Map<Integer, List<String>> byLength = names.stream()
    .collect(Collectors.groupingBy(String::length));

List<Integer> firstFive = Stream.iterate(1, n -> n + 1)
    .limit(5)
    .toList(); // [1, 2, 3, 4, 5], JDK 16+

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10_000; i++) {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return null;
        });
    }
} // executor.close() czeka na zakończenie wszystkich zadań

private final ReentrantLock lock = new ReentrantLock();

void transfer() {
    lock.lock();
    try {
        // blokująca operacja I/O nie przypina wątku nośnego
    } finally {
        lock.unlock();
    }
}