creating and destroying objects

void main() {
    IO.println(List.of(1).getClass().getSimpleName());       // a tiny class for 1-2 items
    IO.println(List.of(1, 2, 3).getClass().getSimpleName()); // a general one for more
    IO.println(Integer.valueOf(127) == Integer.valueOf(127)); // same cached object
}

List12
ListN
true

final class Coffee {
    private final int ml, shots;
    private final String milk;
    private final boolean iced;
 
    private Coffee(Builder b) { ml = b.ml; shots = b.shots; milk = b.milk; iced = b.iced; }
 
    static Builder ofSize(int ml) { return new Builder(ml); }
 
    static final class Builder {
        private final int ml;          // required
        private int shots = 1;         // optional, with defaults
        private String milk = "none";
        private boolean iced;
 
        private Builder(int ml) { this.ml = ml; }
        Builder shots(int n) { shots = n; return this; }
        Builder milk(String m) { milk = m; return this; }
        Builder iced() { iced = true; return this; }
 
        Coffee build() {
            if (shots < 1 || shots > 4) throw new IllegalArgumentException("shots: " + shots);
            return new Coffee(this); // validate once, on the finished set of values
        }
    }
 
    @Override public String toString() {
        return ml + "ml, " + shots + " shot(s), milk=" + milk + (iced ? ", iced" : "");
    }
}
 
public class Main {
    public static void main(String[] args) {
        System.out.println(Coffee.ofSize(350).shots(2).milk("oat").iced().build());
    }
}

350ml, 2 shot(s), milk=oat, iced

import java.lang.reflect.Constructor;
 
class Registry {
    static final Registry INSTANCE = new Registry();
    private Registry() {}
}
 
enum Config { INSTANCE }
 
public class Main {
    public static void main(String[] args) throws Exception {
        Constructor<Registry> c = Registry.class.getDeclaredConstructor();
        c.setAccessible(true);
        System.out.println(c.newInstance() == Registry.INSTANCE); // a second "singleton"
 
        Constructor<Config> e = Config.class.getDeclaredConstructor(String.class, int.class);
        e.setAccessible(true);
        e.newInstance("INSTANCE", 0); // the JVM refuses
    }
}

false
Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects

this one needs a real JVM (reflection), so it doesn't run in the browser. copy it into java Main.java to try it.

public final class Units {
    private Units() { throw new AssertionError("no instances"); }
 
    public static double kmToMiles(double km) { return km * 0.621371; }
}

import java.lang.ref.WeakReference;
import java.util.Arrays;
 
class Stack<T> {
    private Object[] items = new Object[8];
    private int size;
 
    void push(T x) {
        if (size == items.length) items = Arrays.copyOf(items, size * 2);
        items[size++] = x;
    }
 
    @SuppressWarnings("unchecked")
    T pop() {
        T x = (T) items[--size];
        // forgot: items[size] = null;
        return x;
    }
}
 
public class Main {
    public static void main(String[] args) {
        var stack = new Stack<byte[]>();
        stack.push(new byte[1 << 20]);
        var watch = new WeakReference<>(stack.pop()); // we drop our only strong ref
        System.gc();
        System.out.println("still alive: " + (watch.get() != null));
    }
}

still alive: true

import java.lang.ref.Cleaner;
 
final class NativeBuffer implements AutoCloseable {
    private static final Cleaner CLEANER = Cleaner.create();
 
    // the cleanup action must not reference the NativeBuffer itself,
    // or the buffer can never become unreachable
    private record Release(long address) implements Runnable {
        public void run() { System.out.println("freed " + address); }
    }
 
    private final Cleaner.Cleanable cleanable;
 
    NativeBuffer(long address) { cleanable = CLEANER.register(this, new Release(address)); }
 
    @Override public void close() { cleanable.clean(); } // runs Release at most once
}
 
public class Main {
    public static void main(String[] args) {
        try (var buf = new NativeBuffer(0xCAFE)) {
            System.out.println("using it");
        }
        System.out.println("done");
    }
}

using it
freed 51966
done

class Conn implements AutoCloseable {
    void read() { throw new IllegalStateException("read failed"); }
    public void close() { throw new IllegalStateException("close failed"); }
}
 
public class Main {
    public static void main(String[] args) {
        try (Conn c = new Conn()) {
            c.read();
        } catch (IllegalStateException e) {
            System.out.println("caught: " + e.getMessage());
            for (Throwable s : e.getSuppressed()) System.out.println("suppressed: " + s.getMessage());
        }
    }
}

caught: read failed
suppressed: close failed