Records.java

package com.example.records;

import java.util.*;
import java.util.stream.Collectors;
import java.io.Serializable;
// import org.jetbrains.annotations.NotNull;

public class Records {

    public static void testSimpleRecord() {
        record Person(String name, int age) {}
        Person p = new Person("Alice", 30);
        System.out.println(p.name() + ", " + p.age());
    }

    public static void testCustomConstructor() {
        record Email(String value) {
            public Email {
                if (!value.contains("@"))
                    throw new IllegalArgumentException("Invalid email: " + value);
            }
        }
        Email e = new Email("user@example.com");
        System.out.println(e);
    }

    public static void testAdditionalMethods() {
        record Point(int x, int y) {
            public int manhattanDistance() { return Math.abs(x) + Math.abs(y); }
        }
        Point p = new Point(5, -3);
        System.out.println(p.manhattanDistance());
    }

    public static void testCustomToString() {
        record User(String username) {
            @Override public String toString() { return "User: " + username; }
        }
        User u = new User("anuj");
        System.out.println(u);
    }

    public static void testMethodUsage() {
        record Config(String env, int retries) {}
        class App {
            Config getConfig() { return new Config("prod", 3); }
            void printConfig(Config cfg) { System.out.println(cfg); }
        }
        App app = new App();
        Config c = app.getConfig();
        app.printConfig(c);
    }

    // public static void testAnnotations() {
    //     record Product(@NotNull String id, double price) {}
    //     Product p = new Product("A123", 99.99);
    //     System.out.println(p);
    // }

    public static void testNestedRecords() {
        record Department(String name) {}
        record Employee(String name, Department dept) {}
        Department d = new Department("HR");
        Employee e = new Employee("Bob", d);
        System.out.println(e);
    }

    public static void testVarUsage() {
        record Item(String name, int price) {}
        List<Item> items = List.of(new Item("Pen", 10), new Item("Book", 100));
        for (var item : items) {
            System.out.println(item.name() + " - " + item.price());
        }
    }

    public static void testInnerClass() {
        record Coordinates(int x, int y) {}
        class Map {
            class Marker {
                Coordinates location;
                Marker(int x, int y) { this.location = new Coordinates(x, y); }
            }
        }
        Map.Marker m = new Map().new Marker(1, 2);
        System.out.println(m.location);
    }

    public static void testLambdas() {
        record Task(String name, int priority) {}
        List<Task> tasks = List.of(new Task("Clean", 4), new Task("Deploy", 8));
        List<String> result = tasks.stream()
                .filter(t -> t.priority() > 5)
                .map(Task::name)
                .collect(Collectors.toList());
        System.out.println(result);
    }

    public static void testGenerics() {
        record Wrapper<T>(T value) { public T get() { return value; } }
        Wrapper<Integer> w = new Wrapper<>(42);
        System.out.println(w.get());
    }

    public static void testInterfaces() {
        record UserRecord(String name) implements Comparable<UserRecord>, Serializable {
            @Override public int compareTo(UserRecord other) { return name.compareTo(other.name); }
        }
        UserRecord u1 = new UserRecord("Alice");
        UserRecord u2 = new UserRecord("Bob");
        System.out.println(u1.compareTo(u2));
    }

    public static void testOverload() {
        record User(String id) {}
        class Logger {
            void log(User u) { System.out.println("User: " + u); }
            void log(String s) { System.out.println("String: " + s); }
        }
        Logger l = new Logger();
        l.log(new User("U1"));
        l.log("message");
    }

    public static void testCollections() {
        record Key(String name, int version) {}
        Map<Key, String> map = Map.of(new Key("alpha", 1), "value");
        System.out.println(map);
    }

    public static void testTryWithResources() {
        record Resource(String name) implements AutoCloseable {
            public void close() { System.out.println("Closed " + name); }
        }
        try (Resource r = new Resource("r1")) {
            System.out.println("Using " + r.name());
        }
    }

    public static void testControlFlow() {
        record Person(String name, int age) {}
        Person p1 = new Person("Alice", 30);
        Person p2 = new Person("Alice", 30);
        if (p1.equals(p2)) {
            System.out.println("Same person");
        }
        System.out.println(p1.hashCode());
        System.out.println(p1.toString());
    }

    public static void main(String[] args) {
        testSimpleRecord();
        testCustomConstructor();
        testAdditionalMethods();
        testCustomToString();
        testMethodUsage();
        // testAnnotations();
        testNestedRecords();
        testVarUsage();
        testInnerClass();
        testLambdas();
        testGenerics();
        testInterfaces();
        testOverload();
        testCollections();
        testTryWithResources();
        testControlFlow();
    }
}