How to initialize a list in one line in Java

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> langs = List.of("Java", "Kotlin", "Scala");
        System.out.println(langs);
        System.out.println(langs.size() + " " + langs.get(0) + " " + langs.contains("Scala"));

        // The list is unmodifiable: add, remove and set all throw
        try {
            langs.add("Groovy");
        } catch (UnsupportedOperationException e) {
            System.out.println("add failed: " + e.getClass().getSimpleName());
        }

        // Nulls are rejected when the list is built
        try {
            List.of("Java", null);
        } catch (NullPointerException e) {
            System.out.println("null rejected: " + e.getClass().getSimpleName());
        }

        // Zero, one or many elements all work
        List<Integer> none = List.of();
        List<Integer> one = List.of(42);
        System.out.println(none + " " + one);
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // Copy fixed starting values into a real, growable ArrayList
        List<String> todo = new ArrayList<>(List.of("write", "test"));
        todo.add("ship");
        todo.set(0, "draft");
        todo.remove("test");
        System.out.println(todo);

        // An empty list to fill later: the diamond <> infers <Integer>
        List<Integer> scores = new ArrayList<>();
        scores.add(90);
        Collections.addAll(scores, 75, 82, 68);
        Collections.sort(scores);
        System.out.println(scores);

        // The copy is independent of the list it came from
        List<String> base = List.of("a", "b");
        List<String> copy = new ArrayList<>(base);
        copy.add("c");
        System.out.println(base + " " + copy);
    }
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        // Arrays.asList: fixed size, but elements can be replaced
        List<String> colors = Arrays.asList("red", "green", "blue");
        colors.set(1, "lime");
        System.out.println(colors);
        try {
            colors.add("black");
        } catch (UnsupportedOperationException e) {
            System.out.println("add failed: " + e.getClass().getSimpleName());
        }

        // It is a view of the array: writes go straight through
        String[] letters = {"a", "b", "c"};
        List<String> view = Arrays.asList(letters);
        view.set(0, "z");
        System.out.println(Arrays.toString(letters));

        // Java 16+: Stream.toList() returns an unmodifiable list
        List<Integer> squares = IntStream.rangeClosed(1, 5).map(n -> n * n).boxed().toList();
        System.out.println(squares);

        // Java 8: Collectors.toList() (mutability is not guaranteed)
        List<String> upper = Stream.of("x", "y").map(String::toUpperCase).collect(Collectors.toList());
        System.out.println(upper);

        // Guaranteed ArrayList you can keep adding to
        List<String> names = Stream.of("ann", "bob").collect(Collectors.toCollection(ArrayList::new));
        names.add("cy");
        System.out.println(names);
    }
}

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        // Set.of: unmodifiable, no duplicates, no nulls
        Set<String> vowels = Set.of("a", "e", "i", "o", "u");
        System.out.println(vowels.contains("e") + " " + vowels.size());
        System.out.println(new TreeSet<>(vowels)); // sorted copy: Set.of order is unspecified

        // A HashSet you can change: copy the values in
        Set<String> tags = new HashSet<>(Set.of("java", "jvm"));
        tags.add("lts");
        System.out.println(new TreeSet<>(tags));

        // Map.of: key, value, key, value... (up to 10 pairs)
        Map<String, Integer> ports = Map.of("http", 80, "https", 443, "ssh", 22);
        System.out.println(ports.get("https") + " " + ports.containsKey("ftp"));

        // Map.ofEntries: any number of pairs, and easier to read
        Map<String, Integer> stock = Map.ofEntries(
                Map.entry("apples", 12),
                Map.entry("pears", 0),
                Map.entry("plums", 7));
        System.out.println(new TreeMap<>(stock));

        // A HashMap you can change: copy the pairs in
        Map<String, Integer> counts = new HashMap<>(Map.of("a", 1, "b", 1));
        counts.merge("a", 1, Integer::sum);
        counts.put("c", 1);
        System.out.println(new TreeMap<>(counts));

        // Duplicates are treated as a bug and rejected
        try {
            Set.of("x", "x");
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }
    }
}

import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;

public class Main {
    // A constant lookup table: built once, when the class loads
    static final Map<Integer, String> STATUS = Map.of(
            200, "OK",
            404, "Not Found",
            500, "Server Error");

    // Values that need code to compute: a static initializer block
    static final Map<Character, Integer> POSITIONS;
    static {
        Map<Character, Integer> m = new HashMap<>();
        for (char c = 'a'; c <= 'e'; c++) {
            m.put(c, c - 'a' + 1);
        }
        POSITIONS = Collections.unmodifiableMap(m);
    }

    // Double-brace initialization: an anonymous subclass plus an instance initializer
    Map<String, Integer> build() {
        return new HashMap<>() {{
            put("one", 1);
            put("two", 2);
        }};
    }

    public static void main(String[] args) {
        System.out.println(STATUS.get(404));
        System.out.println(new TreeMap<>(POSITIONS));

        Map<String, Integer> dbi = new Main().build();
        System.out.println(new TreeMap<>(dbi));

        // It is not a HashMap but a new class, Main$1...
        System.out.println(dbi.getClass().getName() + " " + (dbi.getClass() == HashMap.class));

        // ...with a hidden field pointing at the Main object that built it
        System.out.println(Arrays.toString(dbi.getClass().getDeclaredFields()));
    }
}