모던 Java 완전 정복: Java 17/21 핵심 문법 가이드

// 기존 방식 (boilerplate 가득)
public class PersonOld {
    private final String name;
    private final int age;

    public PersonOld(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() { return name; }
    public int getAge() { return age; }

    @Override
    public boolean equals(Object o) { /* ... */ }
    @Override
    public int hashCode() { /* ... */ }
    @Override
    public String toString() { /* ... */ }
}

// Record 방식 (한 줄!)
public record Person(String name, int age) {}

// 사용
Person p = new Person("Alice", 30);
System.out.println(p.name()); // "Alice"  (getter 이름은 필드명 그대로)
System.out.println(p);        // Person[name=Alice, age=30]

// 커스텀 생성자로 유효성 검사
public record Person(String name, int age) {
    public Person {
        if (name == null || name.isBlank()) throw new IllegalArgumentException("name cannot be blank");
        if (age < 0 || age > 150) throw new IllegalArgumentException("invalid age: " + age);
    }

    // 추가 메서드 정의 가능
    public String greeting() {
        return "Hello, I'm " + name + " and I'm " + age + " years old.";
    }
}

// Record는 인터페이스 구현 가능
public record Point(double x, double y) implements Comparable<Point> {
    @Override
    public int compareTo(Point other) {
        return Double.compare(this.distance(), other.distance());
    }

    private double distance() {
        return Math.sqrt(x * x + y * y);
    }
}

// Shape는 오직 Circle, Rectangle, Triangle만 상속 가능
public sealed class Shape permits Circle, Rectangle, Triangle {}

public final class Circle extends Shape {
    private final double radius;
    public Circle(double radius) { this.radius = radius; }
    public double radius() { return radius; }
}

public final class Rectangle extends Shape {
    private final double width, height;
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    public double width() { return width; }
    public double height() { return height; }
}

public non-sealed class Triangle extends Shape {
    // non-sealed: Triangle을 상속한 클래스는 제한 없음
    private final double base, height;
    public Triangle(double base, double height) {
        this.base = base;
        this.height = height;
    }
}

// 인터페이스에도 sealed 적용 가능
public sealed interface Result<T> permits Result.Success, Result.Failure {
    record Success<T>(T value) implements Result<T> {}
    record Failure<T>(String error) implements Result<T> {}
}

// 기존 방식
if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.length());
}

// 모던 방식 (Pattern Matching)
if (obj instanceof String s) {
    System.out.println(s.length()); // s는 String으로 자동 캐스팅
}

// 조건과 결합
if (obj instanceof String s && s.length() > 5) {
    System.out.println("Long string: " + s);
}

// 부정
if (!(obj instanceof String s)) {
    System.out.println("Not a string");
    return;
}
// 이 시점부터 s 사용 가능
System.out.println(s.toUpperCase());

// 타입 기반 switch
public double calculateArea(Shape shape) {
    return switch (shape) {
        case Circle c -> Math.PI * c.radius() * c.radius();
        case Rectangle r -> r.width() * r.height();
        case Triangle t -> 0.5 * t.base() * t.height();
        // sealed class이므로 default 불필요 (모든 케이스 커버)
    };
}

// Guarded Pattern (조건부 패턴)
public String classify(Object obj) {
    return switch (obj) {
        case Integer i when i < 0 -> "Negative integer: " + i;
        case Integer i when i == 0 -> "Zero";
        case Integer i -> "Positive integer: " + i;
        case String s when s.isEmpty() -> "Empty string";
        case String s -> "String: " + s;
        case null -> "Null value";
        default -> "Other: " + obj.getClass().getSimpleName();
    };
}

// Record Pattern
public String describePoint(Object obj) {
    return switch (obj) {
        case Point(double x, double y) when x == 0 && y == 0 -> "Origin";
        case Point(double x, double y) when x == 0 -> "On Y-axis at " + y;
        case Point(double x, double y) when y == 0 -> "On X-axis at " + x;
        case Point(double x, double y) -> "Point at (" + x + ", " + y + ")";
        default -> "Not a point";
    };
}

// 기존 방식
String json = "{\n" +
    "  \"name\": \"Alice\",\n" +
    "  \"age\": 30\n" +
    "}";

// Text Block
String json = """
        {
          "name": "Alice",
          "age": 30
        }
        """;

// SQL 예시
String sql = """
        SELECT u.id, u.name, o.total
        FROM users u
        JOIN orders o ON u.id = o.user_id
        WHERE u.active = true
        ORDER BY o.total DESC
        """;

// HTML
String html = """
        <html>
            <body>
                <h1>Hello, World!</h1>
            </body>
        </html>
        """;

// 들여쓰기 제어: \s (trailing whitespace 유지), \ (줄바꿈 없애기)
String oneLine = """
        Hello \
        World\
        """; // "Hello World"

// 기존 플랫폼 스레드
Thread platformThread = new Thread(() -> {
    System.out.println("Platform thread: " + Thread.currentThread());
});
platformThread.start();

// Virtual Thread 생성
Thread virtualThread = Thread.ofVirtual()
    .name("my-virtual-thread")
    .start(() -> {
        System.out.println("Virtual thread: " + Thread.currentThread());
    });

// ExecutorService로 Virtual Thread 사용
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
    List<Future<String>> futures = new ArrayList<>();
    for (int i = 0; i < 10_000; i++) {
        int taskId = i;
        futures.add(executor.submit(() -> {
            // I/O 차단 작업도 OK - Virtual Thread는 블로킹 시 마운트 해제
            Thread.sleep(100);
            return "Task " + taskId + " completed";
        }));
    }
    // 모든 작업 완료 대기
    for (Future<String> f : futures) {
        System.out.println(f.get());
    }
}

// Spring Boot와 함께 사용 (application.properties)
// spring.threads.virtual.enabled=true

// 구조적 동시성 (Structured Concurrency, preview)
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Future<User> user = scope.fork(() -> fetchUser(userId));
    Future<List<Order>> orders = scope.fork(() -> fetchOrders(userId));
    scope.join().throwIfFailed();
    return new UserProfile(user.resultNow(), orders.resultNow());
}

// SequencedCollection: getFirst(), getLast(), addFirst(), addLast(), reversed()
List<String> list = new ArrayList<>(List.of("a", "b", "c"));
System.out.println(list.getFirst()); // "a"
System.out.println(list.getLast());  // "c"
list.addFirst("z");                  // ["z", "a", "b", "c"]
list.addLast("x");                   // ["z", "a", "b", "c", "x"]
List<String> reversed = list.reversed(); // ["x", "c", "b", "a", "z"]

// SequencedMap: firstEntry(), lastEntry(), putFirst(), putLast(), reversed()
LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
map.put("one", 1);
map.put("two", 2);
map.put("three", 3);
System.out.println(map.firstEntry()); // one=1
System.out.println(map.lastEntry());  // three=3

// 기본 형태
Runnable r = () -> System.out.println("Hello");
Comparator<String> comp = (a, b) -> a.compareTo(b);

// 블록 람다 (여러 줄)
Function<Integer, Integer> factorial = n -> {
    int result = 1;
    for (int i = 1; i <= n; i++) result *= i;
    return result;
};

// 타입 추론
List<String> names = List.of("Charlie", "Alice", "Bob");
names.sort((a, b) -> a.compareTo(b));
// 또는 메서드 참조
names.sort(String::compareTo);

// Function<T, R>: T -> R
Function<String, Integer> strLen = String::length;
Function<Integer, Integer> doubler = x -> x * 2;
Function<String, Integer> lenThenDouble = strLen.andThen(doubler);
System.out.println(lenThenDouble.apply("Hello")); // 10

// BiFunction<T, U, R>: T, U -> R
BiFunction<String, Integer, String> repeat = (s, n) -> s.repeat(n);
System.out.println(repeat.apply("Java", 3)); // "JavaJavaJava"

// Predicate<T>: T -> boolean
Predicate<String> isLong = s -> s.length() > 5;
Predicate<String> startsWithA = s -> s.startsWith("A");
Predicate<String> combined = isLong.and(startsWithA);
Predicate<String> either = isLong.or(startsWithA);
Predicate<String> notLong = isLong.negate();

// Supplier<T>: () -> T
Supplier<LocalDate> today = LocalDate::now;
Supplier<List<String>> listFactory = ArrayList::new;

// Consumer<T>: T -> void
Consumer<String> printer = System.out::println;
Consumer<String> logger = s -> log.info("Processing: {}", s);
Consumer<String> both = printer.andThen(logger);

// UnaryOperator<T>: T -> T (Function의 특수화)
UnaryOperator<String> toUpper = String::toUpperCase;
UnaryOperator<Integer> increment = x -> x + 1;

// BinaryOperator<T>: T, T -> T
BinaryOperator<Integer> add = Integer::sum;
BinaryOperator<String> concat = String::concat;

// 1. 정적 메서드 참조: ClassName::staticMethod
Function<String, Integer> parseInt = Integer::parseInt;
Comparator<String> comp = String::compareTo; // 아니, 이건 인스턴스 메서드

// 2. 특정 인스턴스의 메서드 참조: instance::instanceMethod
String prefix = "Hello, ";
Function<String, String> greeter = prefix::concat;
System.out.println(greeter.apply("World")); // "Hello, World"

// 3. 임의 인스턴스의 메서드 참조: ClassName::instanceMethod
Function<String, String> upper = String::toUpperCase;
Comparator<String> byLength = Comparator.comparingInt(String::length);

// 4. 생성자 참조: ClassName::new
Supplier<ArrayList<String>> listCreator = ArrayList::new;
Function<String, StringBuilder> sbCreator = StringBuilder::new;
BiFunction<String, Integer, String> repeater = String::new; // 아님, 예시용

List<Employee> employees = List.of(
    new Employee("Alice", "Engineering", 90_000),
    new Employee("Bob", "Engineering", 80_000),
    new Employee("Charlie", "Marketing", 60_000),
    new Employee("Diana", "Marketing", 70_000),
    new Employee("Eve", "Engineering", 95_000)
);

// filter + map + collect
List<String> highEarnerNames = employees.stream()
    .filter(e -> e.salary() > 75_000)
    .map(Employee::name)
    .sorted()
    .collect(Collectors.toList());
// Java 16+: .toList() (불변 리스트)

// flatMap: Stream<Stream<T>> -> Stream<T>
List<List<Integer>> nested = List.of(List.of(1, 2, 3), List.of(4, 5), List.of(6));
List<Integer> flat = nested.stream()
    .flatMap(Collection::stream)
    .collect(Collectors.toList());
// [1, 2, 3, 4, 5, 6]

// reduce
int totalSalary = employees.stream()
    .mapToInt(Employee::salary)
    .sum(); // 또는 reduce(0, Integer::sum)

OptionalDouble avgSalary = employees.stream()
    .mapToInt(Employee::salary)
    .average();

// groupingBy
Map<String, List<Employee>> byDept = employees.stream()
    .collect(Collectors.groupingBy(Employee::department));

Map<String, Double> avgSalaryByDept = employees.stream()
    .collect(Collectors.groupingBy(
        Employee::department,
        Collectors.averagingInt(Employee::salary)
    ));

Map<String, Long> countByDept = employees.stream()
    .collect(Collectors.groupingBy(Employee::department, Collectors.counting()));

// partitioningBy
Map<Boolean, List<Employee>> partition = employees.stream()
    .collect(Collectors.partitioningBy(e -> e.salary() > 75_000));
// true -> 고연봉자, false -> 나머지

// joining
String names = employees.stream()
    .map(Employee::name)
    .collect(Collectors.joining(", ", "[", "]"));
// "[Alice, Bob, Charlie, Diana, Eve]"

// toMap
Map<String, Integer> nameSalaryMap = employees.stream()
    .collect(Collectors.toMap(Employee::name, Employee::salary));

// findFirst, findAny, anyMatch, allMatch, noneMatch
Optional<Employee> first = employees.stream()
    .filter(e -> e.department().equals("Engineering"))
    .findFirst();

boolean anyHigh = employees.stream().anyMatch(e -> e.salary() > 100_000);
boolean allAbove50k = employees.stream().allMatch(e -> e.salary() > 50_000);

// Optional 생성
Optional<String> opt1 = Optional.of("value");      // null 불가
Optional<String> opt2 = Optional.ofNullable(null); // null 허용 -> empty
Optional<String> opt3 = Optional.empty();

// 값 추출
String val1 = opt1.get();                          // NoSuchElementException 위험
String val2 = opt1.orElse("default");              // 기본값 (항상 평가됨)
String val3 = opt1.orElseGet(() -> computeDefault()); // lazy 평가
String val4 = opt1.orElseThrow(() -> new NotFoundException("not found"));

// 변환
Optional<Integer> length = opt1.map(String::length);
Optional<String> upper = opt1.map(String::toUpperCase);

// flatMap: Optional<Optional<T>> 방지
Optional<Address> address = Optional.of(user)
    .flatMap(u -> Optional.ofNullable(u.getAddress()));

// 조건부 처리
opt1.ifPresent(System.out::println);
opt1.ifPresentOrElse(
    v -> System.out.println("Found: " + v),
    () -> System.out.println("Not found")
);

// filter
Optional<String> longVal = opt1.filter(s -> s.length() > 3);

// 안티패턴: Optional.get() without isPresent() 체크
// 안티패턴: 메서드 파라미터로 Optional 사용 (권장하지 않음)
// 권장: 반환값에만 Optional 사용

// 병렬 스트림 - CPU 바운드 작업에 적합
List<Integer> numbers = IntStream.rangeClosed(1, 1_000_000)
    .boxed().collect(Collectors.toList());

long sum = numbers.parallelStream()
    .mapToLong(Integer::longValue)
    .sum(); // 안전: 상태 없는 연산

// 주의: 공유 상태 변경 (스레드 불안전)
List<Integer> results = new ArrayList<>();
numbers.parallelStream()
    .filter(n -> n % 2 == 0)
    .forEach(results::add); // 위험! ArrayList는 thread-safe 하지 않음

// 올바른 방법: collect 사용
List<Integer> safeResults = numbers.parallelStream()
    .filter(n -> n % 2 == 0)
    .collect(Collectors.toList()); // thread-safe

// I/O 바운드 작업에는 Virtual Threads가 더 적합
// 병렬 스트림은 ForkJoinPool.commonPool() 사용 -> 풀 고갈 주의

// 공변(Covariant): extends - 읽기(Producer)에 사용
public double sumList(List<? extends Number> list) {
    double sum = 0;
    for (Number n : list) {
        sum += n.doubleValue(); // 읽기 OK
    }
    // list.add(1.0); // 컴파일 에러! 쓰기 불가
    return sum;
}
// 호출: sumList(List<Integer>), sumList(List<Double>) 모두 가능

// 반공변(Contravariant): super - 쓰기(Consumer)에 사용
public void addNumbers(List<? super Integer> list) {
    list.add(1);
    list.add(2); // 쓰기 OK
    // Integer n = list.get(0); // 컴파일 에러! 타입 보장 불가 (Object로만 읽기)
    Object obj = list.get(0); // OK
}
// 호출: addNumbers(List<Integer>), addNumbers(List<Number>), addNumbers(List<Object>) 가능

// 복사 예시 (PECS 완전 적용)
public static <T> void copy(List<? super T> dest, List<? extends T> src) {
    for (T item : src) {  // src는 Producer -> extends
        dest.add(item);   // dest는 Consumer -> super
    }
}

// 비한정 와일드카드: ? (모든 타입)
public void printList(List<?> list) {
    for (Object o : list) {
        System.out.println(o);
    }
}

// 제네릭 메서드
public static <T extends Comparable<T>> T max(T a, T b) {
    return a.compareTo(b) >= 0 ? a : b;
}

// 재귀 타입 바운드
public static <T extends Comparable<T>> T findMax(List<T> list) {
    return list.stream().max(Comparator.naturalOrder()).orElseThrow();
}

// 타입 소거 (Type Erasure)
// 컴파일 후 List<String>은 List가 됨 (런타임에 타입 정보 없음)
List<String> strings = new ArrayList<>();
List<Integer> integers = new ArrayList<>();
System.out.println(strings.getClass() == integers.getClass()); // true!

// instanceof에 제네릭 타입 사용 불가
// if (obj instanceof List<String>) {} // 컴파일 에러

// 올바른 방법
if (obj instanceof List<?> list && !list.isEmpty() && list.get(0) instanceof String) {
    List<String> stringList = (List<String>) list; // unchecked warning
}

// 제네릭 배열 생성 불가
// T[] arr = new T[10]; // 컴파일 에러
// 해결책:
@SuppressWarnings("unchecked")
T[] arr = (T[]) new Object[10];
// 또는 리스트 사용
List<T> list = new ArrayList<>();

// 불변 List (null 불가, 순서 유지)
List<String> immutableList = List.of("a", "b", "c");
// immutableList.add("d"); // UnsupportedOperationException

// 불변 Set
Set<Integer> immutableSet = Set.of(1, 2, 3, 4, 5);
// Set.of는 순서 미보장, 중복 불가

// 불변 Map
Map<String, Integer> immutableMap = Map.of(
    "one", 1,
    "two", 2,
    "three", 3
);

// 10개 이상: Map.ofEntries
Map<String, Integer> bigMap = Map.ofEntries(
    Map.entry("a", 1),
    Map.entry("b", 2),
    Map.entry("c", 3)
    // ...
);

// 복사본 (불변)
List<String> original = new ArrayList<>(List.of("a", "b"));
List<String> copy = List.copyOf(original);
Map<String, Integer> mapCopy = Map.copyOf(immutableMap);

// HashMap: 순서 없음, O(1) 평균 (일반적인 경우)
Map<String, Integer> hashMap = new HashMap<>();

// LinkedHashMap: 삽입 순서 유지, O(1) 평균
Map<String, Integer> linkedMap = new LinkedHashMap<>();

// TreeMap: 키 기준 정렬, O(log n)
Map<String, Integer> treeMap = new TreeMap<>();
Map<String, Integer> reverseMap = new TreeMap<>(Comparator.reverseOrder());

// ConcurrentHashMap: 스레드 안전, 세그먼트 잠금
ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();
concurrentMap.computeIfAbsent("key", k -> 0);
concurrentMap.merge("key", 1, Integer::sum); // 원자적 카운터

// EnumMap: Enum 키, 매우 빠름
EnumMap<DayOfWeek, String> schedule = new EnumMap<>(DayOfWeek.class);

// ArrayList: 랜덤 접근 O(1), 삽입/삭제 O(n)
List<String> arrayList = new ArrayList<>();

// LinkedList: 삽입/삭제 O(1), 랜덤 접근 O(n) (실제로는 캐시 미스로 느림)
// 권장하지 않음 - ArrayDeque가 대부분의 경우 더 빠름

// ArrayDeque: 양방향 큐, 스택/큐 역할 모두 가능, 빠름
Deque<String> deque = new ArrayDeque<>();
deque.push("first");      // 스택: 앞에 추가
deque.offerLast("last");  // 큐: 뒤에 추가
String top = deque.peek(); // 첫 번째 확인 (제거 없음)
String removed = deque.poll(); // 첫 번째 제거

// CopyOnWriteArrayList: 읽기 많고 쓰기 적은 경우, 스레드 안전
CopyOnWriteArrayList<String> cowList = new CopyOnWriteArrayList<>();

// Checked Exception: 컴파일러가 처리 강제 (IOException, SQLException 등)
public String readFile(String path) throws IOException {
    return Files.readString(Path.of(path));
}

// Unchecked Exception: RuntimeException 하위 (처리 선택)
public int divide(int a, int b) {
    if (b == 0) throw new ArithmeticException("Division by zero");
    return a / b;
}

// 커스텀 예외 계층 설계
public class AppException extends RuntimeException {
    private final String errorCode;

    public AppException(String errorCode, String message) {
        super(message);
        this.errorCode = errorCode;
    }

    public AppException(String errorCode, String message, Throwable cause) {
        super(message, cause);
        this.errorCode = errorCode;
    }

    public String getErrorCode() { return errorCode; }
}

public class ResourceNotFoundException extends AppException {
    public ResourceNotFoundException(String resourceType, Object id) {
        super("RESOURCE_NOT_FOUND",
              resourceType + " not found with id: " + id);
    }
}

public class ValidationException extends AppException {
    private final Map<String, String> fieldErrors;

    public ValidationException(Map<String, String> fieldErrors) {
        super("VALIDATION_FAILED", "Validation failed");
        this.fieldErrors = Map.copyOf(fieldErrors);
    }

    public Map<String, String> getFieldErrors() { return fieldErrors; }
}

// try-with-resources (AutoCloseable 구현체)
public String readAndClose(String path) throws IOException {
    try (BufferedReader reader = new BufferedReader(new FileReader(path))) {
        return reader.lines().collect(Collectors.joining("\n"));
    } // reader.close() 자동 호출
}

// 여러 리소스 (역순으로 닫힘)
public void copyFile(String src, String dest) throws IOException {
    try (
        InputStream in = new FileInputStream(src);
        OutputStream out = new FileOutputStream(dest)
    ) {
        in.transferTo(out);
    }
}

// Multi-catch
public void process(String input) {
    try {
        int value = Integer.parseInt(input);
        String result = riskyOperation(value);
        System.out.println(result);
    } catch (NumberFormatException | IllegalArgumentException e) {
        System.err.println("Invalid input: " + e.getMessage());
    } catch (RuntimeException e) {
        log.error("Unexpected error", e);
        throw e; // 재발생
    }
}

// Effective Java: 예외를 삼키지 말 것
// Bad:
try { riskyOperation(); } catch (Exception e) { /* 무시 */ }

// Good:
try { riskyOperation(); } catch (Exception e) {
    log.error("Operation failed", e);
    throw new AppException("OPERATION_FAILED", "Failed to complete operation", e);
}

// 비동기 작업 체인
CompletableFuture<String> future = CompletableFuture
    .supplyAsync(() -> fetchUserId())          // 비동기 시작
    .thenApplyAsync(id -> fetchUser(id))       // 변환 (새 스레드)
    .thenApply(user -> user.getName())         // 변환 (같은 스레드)
    .exceptionally(ex -> "Unknown User");      // 예외 처리

// thenCompose: flatMap 역할 (비동기 체인)
CompletableFuture<Order> orderFuture = CompletableFuture
    .supplyAsync(() -> fetchUser(userId))
    .thenCompose(user -> CompletableFuture.supplyAsync(() -> fetchLatestOrder(user)));

// thenCombine: 두 비동기 결과 합치기
CompletableFuture<User> userFuture = CompletableFuture.supplyAsync(() -> fetchUser(id));
CompletableFuture<List<Order>> ordersFuture = CompletableFuture.supplyAsync(() -> fetchOrders(id));

CompletableFuture<UserProfile> profileFuture = userFuture.thenCombine(
    ordersFuture,
    (user, orders) -> new UserProfile(user, orders)
);

// allOf: 모두 완료까지 대기
CompletableFuture<Void> allDone = CompletableFuture.allOf(
    task1, task2, task3
);
allDone.thenRun(() -> System.out.println("All done!"));

// anyOf: 하나라도 완료
CompletableFuture<Object> firstDone = CompletableFuture.anyOf(task1, task2, task3);

// 타임아웃
CompletableFuture<String> withTimeout = future
    .orTimeout(5, TimeUnit.SECONDS)
    .completeOnTimeout("default", 3, TimeUnit.SECONDS);

// 커스텀 Executor 지정
Executor executor = Executors.newFixedThreadPool(10);
CompletableFuture.supplyAsync(() -> heavyTask(), executor);

// Virtual Thread 활용 - I/O 집약적 작업
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    List<CompletableFuture<String>> tasks = urls.stream()
        .map(url -> CompletableFuture.supplyAsync(() -> httpGet(url), executor))
        .collect(Collectors.toList());

    List<String> results = tasks.stream()
        .map(CompletableFuture::join)
        .collect(Collectors.toList());
}

// ReentrantLock
ReentrantLock lock = new ReentrantLock(true); // fair lock
lock.lock();
try {
    // critical section
} finally {
    lock.unlock(); // finally에서 반드시 해제
}

// tryLock으로 타임아웃
if (lock.tryLock(1, TimeUnit.SECONDS)) {
    try {
        // critical section
    } finally {
        lock.unlock();
    }
} else {
    // 잠금 획득 실패 처리
}

// ReadWriteLock: 다수 읽기, 단일 쓰기
ReadWriteLock rwLock = new ReentrantReadWriteLock();
Map<String, String> cache = new HashMap<>();

public String get(String key) {
    rwLock.readLock().lock();
    try {
        return cache.get(key);
    } finally {
        rwLock.readLock().unlock();
    }
}

public void put(String key, String value) {
    rwLock.writeLock().lock();
    try {
        cache.put(key, value);
    } finally {
        rwLock.writeLock().unlock();
    }
}

// 수동 Builder
public class HttpRequest {
    private final String url;
    private final String method;
    private final Map<String, String> headers;
    private final String body;
    private final int timeoutMs;

    private HttpRequest(Builder builder) {
        this.url = builder.url;
        this.method = builder.method;
        this.headers = Map.copyOf(builder.headers);
        this.body = builder.body;
        this.timeoutMs = builder.timeoutMs;
    }

    public static Builder builder(String url) {
        return new Builder(url);
    }

    public static class Builder {
        private final String url;
        private String method = "GET";
        private Map<String, String> headers = new HashMap<>();
        private String body;
        private int timeoutMs = 5000;

        private Builder(String url) { this.url = url; }

        public Builder method(String method) { this.method = method; return this; }
        public Builder header(String key, String value) { headers.put(key, value); return this; }
        public Builder body(String body) { this.body = body; return this; }
        public Builder timeout(int ms) { this.timeoutMs = ms; return this; }
        public HttpRequest build() { return new HttpRequest(this); }
    }
}

// 사용
HttpRequest request = HttpRequest.builder("https://api.example.com/users")
    .method("POST")
    .header("Content-Type", "application/json")
    .header("Authorization", "Bearer token123")
    .body("{\"name\": \"Alice\"}")
    .timeout(3000)
    .build();

// Result 타입 (Either와 유사)
public sealed interface Result<T> permits Result.Ok, Result.Err {

    record Ok<T>(T value) implements Result<T> {}
    record Err<T>(String message, Throwable cause) implements Result<T> {
        public Err(String message) { this(message, null); }
    }

    static <T> Result<T> ok(T value) { return new Ok<>(value); }
    static <T> Result<T> err(String message) { return new Err<>(message); }
    static <T> Result<T> of(Supplier<T> supplier) {
        try {
            return ok(supplier.get());
        } catch (Exception e) {
            return err(e.getMessage());
        }
    }

    default <U> Result<U> map(Function<T, U> mapper) {
        return switch (this) {
            case Ok<T> ok -> Result.ok(mapper.apply(ok.value()));
            case Err<T> err -> Result.err(err.message());
        };
    }

    default T getOrElse(T defaultValue) {
        return switch (this) {
            case Ok<T> ok -> ok.value();
            case Err<T> ignored -> defaultValue;
        };
    }
}

// 사용 예시
Result<Integer> result = Result.of(() -> Integer.parseInt("123"));
Result<String> mapped = result.map(n -> "Number: " + n);
String output = mapped.getOrElse("Parse failed");
System.out.println(output); // "Number: 123"

// Command 패턴 (ADT)
public sealed interface Command permits Command.CreateUser, Command.DeleteUser, Command.UpdateEmail {
    record CreateUser(String name, String email) implements Command {}
    record DeleteUser(String userId) implements Command {}
    record UpdateEmail(String userId, String newEmail) implements Command {}
}

public void handle(Command command) {
    switch (command) {
        case Command.CreateUser(String name, String email) ->
            userService.create(name, email);
        case Command.DeleteUser(String userId) ->
            userService.delete(userId);
        case Command.UpdateEmail(String userId, String newEmail) ->
            userService.updateEmail(userId, newEmail);
    }
}

// Record를 DTO로 사용
public record CreateUserRequest(
    @NotBlank String name,
    @Email String email,
    @Min(0) @Max(150) int age
) {}

public record UserResponse(
    String id,
    String name,
    String email,
    LocalDateTime createdAt
) {
    public static UserResponse from(User user) {
        return new UserResponse(
            user.getId(),
            user.getName(),
            user.getEmail(),
            user.getCreatedAt()
        );
    }
}

// Controller
@RestController
@RequestMapping("/api/users")
public class UserController {

    @PostMapping
    public ResponseEntity<UserResponse> createUser(
            @RequestBody @Valid CreateUserRequest request) {
        User user = userService.create(request);
        return ResponseEntity.status(HttpStatus.CREATED)
                .body(UserResponse.from(user));
    }
}

// Sealed class로 API 응답 통일
public sealed interface ApiResponse<T> permits ApiResponse.Success, ApiResponse.Error {
    record Success<T>(T data, String message) implements ApiResponse<T> {}
    record Error<T>(String code, String message, List<String> details) implements ApiResponse<T> {}
}