Java 버전별 핵심 변경점 — 8에서 21까지

// 익명 클래스 방식
Comparator<String> comp = new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return a.length() - b.length();
    }
};

// 람다
Comparator<String> comp = (a, b) -> a.length() - b.length();

@FunctionalInterface
public interface Converter<F, T> {
    T convert(F from);
}

Converter<String, Integer> converter = Integer::valueOf;
Integer result = converter.convert("123"); // 123

List<String> names = List.of("김철수", "이영희", "박지성", "김민수", "이하늘");

List<String> result = names.stream()
    .filter(name -> name.startsWith("김"))
    .map(String::toUpperCase)
    .sorted()
    .collect(Collectors.toList());
// [김민수, 김철수]

Optional<String> name = Optional.ofNullable(getUserName());

String result = name
    .filter(n -> n.length() > 2)
    .map(String::toUpperCase)
    .orElse("UNKNOWN");

public interface Loggable {
    // default 메서드 — 구현체에서 오버라이드 가능
    default void log(String msg) {
        System.out.println("[LOG] " + msg);
    }

    // static 메서드 — 유틸리티성
    static Loggable create() {
        return new DefaultLogger();
    }
}

LocalDate today = LocalDate.now();
LocalDateTime dateTime = LocalDateTime.of(2026, 3, 15, 17, 30);
Duration duration = Duration.between(startTime, endTime);
Period period = Period.between(startDate, endDate);

// 불변이라 thread-safe
LocalDate tomorrow = today.plusDays(1); // today는 변하지 않음

// module-info.java
module com.myapp.core {
    requires java.sql;
    exports com.myapp.core.api;        // 이 패키지만 외부에 공개
    opens com.myapp.core.model to com.google.gson; // 리플렉션 허용
}

List<String> list = List.of("a", "b", "c");       // 불변 리스트
Set<String> set = Set.of("x", "y", "z");           // 불변 셋
Map<String, Integer> map = Map.of("a", 1, "b", 2); // 불변 맵

list.add("d"); // UnsupportedOperationException!

jshell> var list = List.of(1, 2, 3)
list ==> [1, 2, 3]

jshell> list.stream().mapToInt(i -> i).sum()
$2 ==> 6

// 타입을 명시할 필요 없이, 컴파일러가 추론
var list = new ArrayList<String>();  // ArrayList<String>으로 추론
var stream = list.stream();          // Stream<String>으로 추론
var map = Map.of("a", 1);           // Map<String, Integer>로 추론

// 좋은 예 — 오른쪽에서 타입이 보임
var reader = new BufferedReader(new FileReader("file.txt"));
var numbers = List.of(1, 2, 3);

// 나쁜 예 — 뭘 반환하는지 모름
var result = service.process(data);

"  hello  ".strip();     // "hello" (유니코드 공백도 처리, trim()과 차이)
"  ".isBlank();          // true
"hello\nworld".lines();  // Stream<String>: ["hello", "world"]
"ha".repeat(3);          // "hahaha"

HttpClient client = HttpClient.newHttpClient();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com/users"))
    .header("Content-Type", "application/json")
    .GET()
    .build();

// 동기 호출
HttpResponse<String> response = client.send(request,
    HttpResponse.BodyHandlers.ofString());

// 비동기 호출
client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
    .thenApply(HttpResponse::body)
    .thenAccept(System.out::println);

// 이 한 줄이
public record Point(int x, int y) {}

// 아래와 동등하다 (대략)
public final class Point {
    private final int x;
    private final int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int x() { return x; }  // getX()가 아니라 x()
    public int y() { return y; }

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

public record Age(int value) {
    public Age {
        if (value < 0 || value > 150) {
            throw new IllegalArgumentException("유효하지 않은 나이: " + value);
        }
    }
}

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

// Java 14+
if (obj instanceof String s) {
    System.out.println(s.length()); // 바로 s 사용
}

if (!(obj instanceof String s)) {
    return;
}
// 여기서 s 사용 가능 (flow scoping)
System.out.println(s.toUpperCase());

// 기존 switch — fall-through 위험
switch (day) {
    case MONDAY:
    case TUESDAY:
        type = "평일 시작";
        break;
    case FRIDAY:
        type = "불금";
        break;
    default:
        type = "기타";
}

// Switch Expression
String type = switch (day) {
    case MONDAY, TUESDAY -> "평일 시작";
    case FRIDAY -> "불금";
    default -> "기타";
};

int numLetters = switch (day) {
    case MONDAY, FRIDAY, SUNDAY -> 6;
    case TUESDAY -> 7;
    default -> {
        String s = day.toString();
        yield s.length();
    }
};

public sealed class Shape
    permits Circle, Rectangle, Triangle {
}

public final class Circle extends Shape {
    private final double radius;
    // ...
}

public final class Rectangle extends Shape {
    private final double width, height;
    // ...
}

public non-sealed class Triangle extends Shape {
    // non-sealed로 선언하면 Triangle은 자유롭게 상속 가능
}

// 기존
String json = "{\n" +
    "  \"name\": \"홍길동\",\n" +
    "  \"age\": 30\n" +
    "}";

// 텍스트 블록 (실제로는 Java 15에서 정식)
String json = """
    {
      "name": "홍길동",
      "age": 30
    }
    """;

// 가상 스레드 직접 생성
Thread vt = Thread.ofVirtual().name("worker").start(() -> {
    System.out.println(Thread.currentThread());
});

// Executor로 사용 — 작업마다 가상 스레드 생성
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 100_000).forEach(i ->
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return i;
        })
    );
}

// synchronized 안에서 블로킹하면 캐리어 스레드가 고정(pinning)됨
synchronized (lock) {
    Thread.sleep(1000); // 캐리어 스레드가 여기 묶여버림
}

// 해결: ReentrantLock 사용
private final ReentrantLock lock = new ReentrantLock();

lock.lock();
try {
    Thread.sleep(1000); // 캐리어 스레드에서 unmount 가능
} finally {
    lock.unlock();
}

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Subtask<String> user = scope.fork(() -> fetchUser());
    Subtask<String> order = scope.fork(() -> fetchOrder());

    scope.join();           // 모든 작업 완료 대기
    scope.throwIfFailed();  // 하나라도 실패하면 예외

    // 모두 성공한 경우에만 여기 도달
    String result = user.get() + " / " + order.get();
}

// sealed class + switch 패턴 매칭
String description = switch (shape) {
    case Circle c    -> "반지름 " + c.radius() + "인 원";
    case Rectangle r -> "가로 " + r.width() + ", 세로 " + r.height();
    case Triangle t  -> "삼각형";
    // sealed class라 default 필요 없음 — 컴파일러가 모든 케이스 보장
};

// Record 패턴 — 구조 분해
record Point(int x, int y) {}
record Line(Point start, Point end) {}

if (obj instanceof Line(Point(var x1, var y1), Point(var x2, var y2))) {
    double length = Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
}

// switch에서 guard 조건
String classify(Object obj) {
    return switch (obj) {
        case Integer i when i > 0  -> "양수";
        case Integer i when i == 0 -> "영";
        case Integer i             -> "음수";
        case String s              -> "문자열: " + s;
        default                    -> "기타";
    };
}

List<Order> orders = getOrders();

// map — 변환
List<String> names = orders.stream()
    .map(Order::getCustomerName)
    .collect(Collectors.toList());

// filter — 조건 필터링
List<Order> expensive = orders.stream()
    .filter(o -> o.getAmount() > 10000)
    .collect(Collectors.toList());

// reduce — 누적 연산
int totalAmount = orders.stream()
    .map(Order::getAmount)
    .reduce(0, Integer::sum);

// collect — 다양한 수집 전략
Map<String, List<Order>> byCustomer = orders.stream()
    .collect(Collectors.groupingBy(Order::getCustomerName));

// flatMap — 중첩 컬렉션 평탄화
List<Item> allItems = orders.stream()
    .flatMap(order -> order.getItems().stream())
    .collect(Collectors.toList());

// map → Stream<List<Item>> (쓸모없는 구조)
orders.stream()
    .map(Order::getItems) // Stream<List<Item>>

// flatMap → Stream<Item> (원하는 구조)
orders.stream()
    .flatMap(order -> order.getItems().stream()) // Stream<Item>

// 병렬 스트림 사용
long count = list.parallelStream()
    .filter(s -> s.length() > 5)
    .count();

// 절대 하지 마라
List<String> results = new ArrayList<>();
stream.parallel().forEach(s -> results.add(s)); // race condition!

// 이렇게 해야 한다
List<String> results = stream.parallel().collect(Collectors.toList());

// orElse — 값이 있어도 항상 기본값 생성을 실행
String result = optional.orElse(createDefault()); // createDefault() 항상 호출됨

// orElseGet — 값이 없을 때만 Supplier 실행
String result = optional.orElseGet(() -> createDefault()); // 필요할 때만 호출

// 안티 패턴 1: Optional을 조건 분기용으로만 쓰기
if (optional.isPresent()) {
    return optional.get();
}
// 이건 null 체크랑 다를 바 없다. 이렇게 쓰자:
return optional.orElse(defaultValue);

// 안티 패턴 2: Optional을 메서드 파라미터로 받기
public void process(Optional<String> name) { } // 하지 마라
public void process(String name) { }           // 그냥 null 체크하거나 오버로딩

// 안티 패턴 3: Optional을 필드로 쓰기
class User {
    private Optional<String> nickname; // 하지 마라 — Serializable 아님
    private String nickname;           // null 허용 필드는 그냥 null로
}

// 안티 패턴 4: Optional.of()에 null 넣기
Optional.of(null);          // NullPointerException!
Optional.ofNullable(null);  // Optional.empty() — 이걸 써야 한다

// 익명 클래스 — 컴파일 시 별도의 .class 파일 생성
Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println(this); // this = 익명 클래스 인스턴스
    }
};

// 람다 — invokedynamic 명령어로 처리, 별도 클래스 파일 없음
Runnable r2 = () -> {
    System.out.println(this); // this = 감싸는 클래스(enclosing class)의 인스턴스
};