Java cheat sheet

import java.util.Arrays;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
 
public class Words {
    public static void main(String[] args) {
        String text = "the cat sat on the mat and the cat slept";
 
        Map<String, Long> counts = Arrays.stream(text.split(" "))
                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
 
        // A HashMap has no order, so sort the entries on the way out:
        // most frequent first, then A to Z.
        counts.entrySet().stream()
                .sorted(Map.Entry.<String, Long>comparingByValue().reversed()
                        .thenComparing(Map.Entry.comparingByKey()))
                .limit(3)
                .forEach(e -> System.out.printf("%-5s %d%n", e.getKey(), e.getValue()));
        // the   3
        // cat   2
        // and   1
    }
}

java Words.java

import java.util.List;
 
public class Shapes {
    static double area(Shape shape) {
        return switch (shape) {
            case Circle c -> Math.PI * c.radius() * c.radius();
            case Rectangle(double w, double h) -> w * h;
            case Square(double side) -> side * side;
        };
    }
 
    public static void main(String[] args) {
        List<Shape> shapes = List.of(new Circle(1), new Rectangle(3, 4), new Square(2));
 
        double total = 0;
        for (Shape shape : shapes) {
            System.out.printf("%-34s %6.2f%n", shape, area(shape));
            total += area(shape);
        }
        System.out.printf("%-34s %6.2f%n", "total", total);
        // Circle[radius=1.0]                   3.14
        // Rectangle[width=3.0, height=4.0]    12.00
        // Square[side=2.0]                     4.00
        // total                               19.14
    }
}
 
sealed interface Shape permits Circle, Rectangle, Square {}
 
record Circle(double radius) implements Shape {}
 
record Rectangle(double width, double height) implements Shape {
    Rectangle {
        if (width <= 0 || height <= 0) {
            throw new IllegalArgumentException("sides must be positive");
        }
    }
}
 
record Square(double side) implements Shape {}

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;
 
public class Config {
    record Setting(String key, String value) {}
 
    // "port = 8080" becomes a Setting. Comments, blanks and junk become empty.
    static Optional<Setting> parse(String line) {
        int eq = line.indexOf('=');
        if (line.isBlank() || line.startsWith("#") || eq < 0) {
            return Optional.empty();
        }
        return Optional.of(new Setting(line.substring(0, eq).strip(), line.substring(eq + 1).strip()));
    }
 
    static List<Setting> load(Path path) throws IOException {
        try (Stream<String> lines = Files.lines(path)) {
            return lines.map(Config::parse).flatMap(Optional::stream).toList();
        }
    }
 
    public static void main(String[] args) throws IOException {
        Path path = Path.of("app.properties");
        Files.writeString(path, """
                # sample settings
                port = 8080
                host=localhost
                not a setting
                """);
 
        List<Setting> settings;
        try {
            settings = load(path);
        } catch (NoSuchFileException e) {
            System.err.println("No config at " + e.getFile() + ", using defaults");
            settings = List.of();
        }
 
        int port = settings.stream()
                .filter(s -> s.key().equals("port"))
                .findFirst()
                .map(s -> Integer.parseInt(s.value()))
                .orElse(80);
 
        System.out.println(settings.size() + " settings, port " + port);
        // 2 settings, port 8080
    }
}

import java.util.ArrayList;
import java.util.List;
 
public class Generics {
    // Works for any type. T is fixed when a Stack is created.
    static class Stack<T> {
        private final List<T> items = new ArrayList<>();
 
        void push(T item) {
            items.add(item);
        }
 
        T pop() {
            if (items.isEmpty()) {
                throw new IllegalStateException("stack is empty");
            }
            return items.removeLast();
        }
    }
 
    // Only for types that can be compared with themselves.
    // Reads from values, so values is ? extends T.
    static <T extends Comparable<? super T>> T largest(List<? extends T> values) {
        T best = values.getFirst();
        for (T value : values) {
            if (value.compareTo(best) > 0) {
                best = value;
            }
        }
        return best;
    }
 
    // Adds to out, so out is ? super Integer: a List<Integer>,
    // List<Number> or List<Object> all work.
    static void addCountingNumbers(List<? super Integer> out, int count) {
        for (int i = 1; i <= count; i++) {
            out.add(i);
        }
    }
 
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();
        stack.push("first");
        stack.push("second");
        System.out.println(stack.pop());                           // second
 
        System.out.println(largest(List.of(3, 9, 4)));             // 9
        System.out.println(largest(List.of("pear", "apple")));     // pear
 
        List<Number> numbers = new ArrayList<>();
        addCountingNumbers(numbers, 3);
        numbers.add(2.5);
        System.out.println(numbers);                               // [1, 2, 3, 2.5]
        // stack.push(42);  // error: 42 is not a String
    }
}