Types and Data

Records declare immutable data carriers concisely; the compiler generates the constructor, accessors, equals, hashCode, and toString. Accessors are named after the components: radius(), not getRadius().

interface Shape {
    double area();
    default String describe() {
        return getClass().getSimpleName() + " area=" + area();
    }
}

record Circle(double radius) implements Shape {
    Circle { // compact constructor for validation
        if (radius < 0) throw new IllegalArgumentException("radius < 0");
    }
    public double area() { return Math.PI * radius * radius; }
}

record Rect(double width, double height) implements Shape {
    public double area() { return width * height; }
}

enum Status {
    ACTIVE("active"), SUSPENDED("suspended");
    private final String label;
    Status(String label) { this.label = label; }
    String label() { return label; }
}

An enum turns a fixed set of constants into a real type. It can carry fields and methods, works naturally with switch, and provides valueOf and values() for free.

Generics basics

Generics parameterize code by type, so one implementation serves many types while the compiler checks everything up front instead of leaving casts for runtime. Type arguments must be reference types, which is why you write List<Integer> rather than List<int>.

record Pair<A, B>(A first, B second) {}

static <T extends Comparable<T>> T max(java.util.List<T> items) {
    T best = items.get(0);
    for (T item : items) {
        if (item.compareTo(best) > 0) best = item;
    }
    return best;
}

var pair = new Pair<>("age", 30); // diamond operator infers the types
String key = pair.first();
int biggest = max(java.util.List.of(3, 9, 4)); // 9

A bound such as T extends Comparable<T> lets you call that type's methods inside the generic code. For parameters you only read from, wildcards like List<? extends Number> make an API accept more argument types.

Collections: List, Set, and Map

The collections framework in java.util separates interfaces from implementations. The convention is to declare variables with the interface type and pick the implementation that suits the job.

import java.util.*;

List<String> langs = new ArrayList<>(List.of("Java", "Go"));
langs.add("Rust");
langs.remove("Go");

Set<String> tags = new HashSet<>();
tags.add("jvm");
tags.add("jvm"); // duplicate is ignored
System.out.println(tags.size()); // 1

Map<String, Integer> stock = new HashMap<>();
stock.put("apple", 3);
stock.merge("apple", 2, Integer::sum); // 5
int pears = stock.getOrDefault("pear", 0);
for (Map.Entry<String, Integer> e : stock.entrySet()) {
    System.out.println(e.getKey() + "=" + e.getValue());
}

List<Integer> fixed = List.of(1, 2, 3); // unmodifiable

Collections from List.of, Set.of, and Map.of are unmodifiable, and add throws UnsupportedOperationException; copy them into a mutable collection, as in the first line, when you need changes. HashMap and HashSet promise no order: use LinkedHashMap for insertion order or TreeMap for sorted keys.

Summary

• Primitives store values; object variables store references. Compare objects with equals.
• Arrays have a fixed length; use collections for data that grows or shrinks.
• Records model immutable data, enums model fixed sets of constants, and interfaces define contracts.
• Generics give type-safe reuse, and List, Set, and Map cover most everyday data structures.