☕
Java 치트시트

Java 17/21 LTS 모던 문법, SDKMAN 설치, Record, Stream API, Optional, Virtual Threads, 동시성, Sealed Class 및 JVM 메모리 튜닝 레퍼런스
#java#jdk#jvm#stream#lambda#record#backend#concurrency#spring최종 업데이트: 2026-09-27
Java 치트시트 핵심 명령어 및 실전 가이드

Java 17/21 LTS 모던 문법, SDKMAN 설치, Record, Stream API, Optional, Virtual Threads, 동시성, Sealed Class 및 JVM 메모리 튜닝 레퍼런스
## 1. JDK 설치 & 버전 관리 (JDK Setup & SDKMAN!)
```bash
# ☕ [1] SDKMAN!을 통한 다중 JDK 버전 관리 (macOS / Linux / WSL2 가장 권장)
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"

# 지원되는 Java 17 / 21 LTS 배포판 목록 확인
sdk list java

# Eclipse Temurin(Adoptium) Java 21 설치 및 기본 버전 지정
sdk install java 21.0.3-tem
sdk default java 21.0.3-tem

# 프로젝트별 .sdkmanrc 자동 버전 전환
sdk env init
sdk env

# 🪟 [2] Windows 환경 설치 (winget)
winget install EclipseAdoptium.Temurin.21.JDK
# JAVA_HOME 환경변수 확인
echo %JAVA_HOME%
java -version
```

## 2. 모던 Java 핵심 문법 (Java 11 ~ 21 Features)
```java
// [1] 지역 변수 타입 추론 (var - Java 10+)
var message = "Hello, Java!"; // String 자동 추론
var userMap = new HashMap<Long, List<String>>(); // 복잡한 제네릭 축약

// [2] 텍스트 블록 (Text Blocks - Java 15+)
// 줄바꿈과 따옴표를 이스케이프 없이 유지 (JSON, SQL 작성 시 탁월)
String json = """
    {
        "id": 1,
        "name": "Lucky",
        "role": "ADMIN"
    }
    """;

// [3] 향상된 Switch 표현식 (Switch Expressions - Java 14+)
// 화살표(->) 문법으로 break 생략 가능, 값 반환 지원
String result = switch (day) {
    case MONDAY, FRIDAY -> "바쁜 날";
    case TUESDAY -> "회의";
    case SATURDAY, SUNDAY -> {
        System.out.println("주말 알림");
        yield "휴식"; // 블록 내에서는 yield로 반환
    }
    default -> "평일";
};

// [4] Pattern Matching for instanceof (Java 16+)
// 불필요한 명시적 형변환(Casting) 제거
if (obj instanceof String s && s.length() > 5) {
    System.out.println(s.toUpperCase()); // 바로 s 변수 사용 가능
}
```

## 3. 레코드 & 봉인된 클래스 (Record & Sealed Class)
```java
// [1] Record (Java 16+ 불변 데이터 객체 DTO)
// 생성자, getter(id(), name()), equals(), hashCode(), toString() 자동 생성
public record UserDto(Long id, String name, String email) {
    // 콤팩트 생성자 (유효성 검증용)
    public UserDto {
        if (name == null || name.isBlank()) {
            throw new IllegalArgumentException("이름은 필수입니다.");
        }
    }

    // 커스텀 편의 메서드 추가 가능
    public String displayName() {
        return name + " (" + email + ")";
    }
}

// [2] Sealed Class (봉인된 클래스 - Java 17+)
// 지정한 하위 클래스 외에는 임의로 상속/구현을 엄격히 제한
public sealed interface Shape permits Circle, Rectangle, Triangle { }

public final class Circle implements Shape { }
public final class Rectangle implements Shape { }
public non-sealed class Triangle implements Shape { } // 하위 확장 허용
```

## 4. 모던 컬렉션 프레임워크 (Collection Factory Methods)
```java
// [1] 불변(Unmodifiable) 컬렉션 팩토리 (Java 9+)
List<String> list = List.of("A", "B", "C"); // 수정 시 UnsupportedOperationException
Set<Integer> set = Set.of(1, 2, 3);
Map<String, Integer> map = Map.of(
    "apple", 1000,
    "banana", 2000
);
// 10개 초과 시 Map.ofEntries() 사용
Map<String, String> largeMap = Map.ofEntries(
    Map.entry("k1", "v1"),
    Map.entry("k2", "v2")
);

// [2] 기존 컬렉션의 안전한 불변 복사본 (List.copyOf)
List<String> original = new ArrayList<>();
List<String> unmodifiableCopy = List.copyOf(original);

// [3] 유용한 Map 편의 메서드 (Java 8+)
Map<String, Integer> scores = new HashMap<>();
scores.putIfAbsent("Lucky", 100);
int current = scores.getOrDefault("Unknown", 0);
scores.computeIfPresent("Lucky", (k, v) -> v + 10); // 110으로 업데이트
scores.computeIfAbsent("NewUser", k -> 50);        // 없으면 50 할당
```

## 5. Stream API & 람다 표현식 (Stream & Lambdas)
```java
List<User> users = List.of(
    new User(1L, "Alice", 25, "SEOUL"),
    new User(2L, "Bob", 35, "BUSAN"),
    new User(3L, "Charlie", 28, "SEOUL")
);

// 1. 필터링, 매핑 및 정렬
List<String> seoulUserNames = users.stream()
    .filter(u -> "SEOUL".equals(u.city()))
    .filter(u -> u.age() >= 20)
    .sorted(Comparator.comparing(User::age).reversed()) // 나이 내림차순
    .map(User::name)
    .toList(); // Java 16+ Unmodifiable List 반환 (Collectors.toList() 단축)

// 2. 그룹핑 (groupingBy - 도시별 사용자 그룹화)
Map<String, List<User>> byCity = users.stream()
    .collect(Collectors.groupingBy(User::city));

// 3. 통계 및 집계
double avgAge = users.stream()
    .mapToInt(User::age)
    .average()
    .orElse(0.0);

// 4. flatMap (중첩 리스트 평탄화)
List<List<String>> nested = List.of(List.of("A", "B"), List.of("C", "D"));
List<String> flat = nested.stream()
    .flatMap(Collection::stream)
    .toList(); // ["A", "B", "C", "D"]
```

## 6. Optional 안전한 널 처리 (Null-Safe Optional)
```java
// [1] Optional 생성
Optional<String> opt = Optional.of("Hello");      // null 불가 (NPE 발생)
Optional<String> optNull = Optional.ofNullable(null); // null 허용 -> Optional.empty()

// [2] 값 추출 및 대체 (안티패턴: get()이나 isPresent() 남용 금지!)
// 권장 패턴 A: orElse (기본값이 이미 생성된 상수일 때)
String val1 = optNull.orElse("DEFAULT");

// 권장 패턴 B: orElseGet (기본값 생성에 비용이 드는 연산일 때 Lazy 평가)
String val2 = optNull.orElseGet(() -> computeDefaultValue());

// 권장 패턴 C: orElseThrow (값이 없으면 커스텀 예외 던지기)
User user = findUserById(id)
    .orElseThrow(() -> new UserNotFoundException("사용자 없음: " + id));

// [3] 값 변환 체이닝
String upper = Optional.ofNullable(user)
    .map(User::getEmail)
    .filter(email -> email.contains("@"))
    .map(String::toUpperCase)
    .orElse("NO_EMAIL");
```

## 7. 가상 스레드 & 동시성 (Virtual Threads - Java 21)
```java
// [1] Virtual Threads (경량 가상 스레드 - 수십만 개 생성 가능)
// I/O 블로킹(DB, HTTP 호출) 시 OS 스레드를 점유하지 않고 언마운트됨
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 10_000).forEach(i -> {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1)); // I/O 대기 흉내
            return "Task " + i;
        });
    });
} // 모든 작업이 끝날 때까지 자동 대기 (AutoCloseable)

// [2] CompletableFuture 비동기 파이프라인
CompletableFuture.supplyAsync(() -> fetchExternalApi())
    .thenApply(json -> parseData(json))
    .thenAccept(data -> saveToDatabase(data))
    .exceptionally(ex -> {
        log.error("비동기 처리 에러", ex);
        return null;
    });

// [3] 가상 스레드 생성 직접 실행
Thread vThread = Thread.ofVirtual()
    .name("virtual-worker-", 1)
    .start(() -> doJob());
```

## 8. 제네릭 & 와일드카드 (Generics & PECS)
```java
// PECS 원칙: Producer Extends, Consumer Super
// 데이터를 꺼내오기만 하면 (Producer) -> <? extends T>
// 데이터를 집어넣기만 하면 (Consumer) -> <? super T>

// 1. 공변성 (Covariance: 꺼내기 읽기 전용)
public void printNumbers(List<? extends Number> list) {
    for (Number n : list) {
        System.out.println(n.doubleValue());
    }
    // list.add(10); // 컴파일 에러! (무엇이 들어올지 몰라 추가 불가)
}

// 2. 반공변성 (Contravariance: 넣기 쓰기 전용)
public void addIntegers(List<? super Integer> list) {
    list.add(1);
    list.add(2); // Integer 및 하위 객체 추가 안전
    // Object obj = list.get(0); // 꺼낼 때는 Object로만 안전
}

// 3. 제네릭 메서드 정의
public <T> T getFirst(List<T> items) {
    return items.isEmpty() ? null : items.get(0);
}
```

## 9. 예외 처리 & 리소스 관리 (Try-with-Resources)
```java
// [1] Try-with-Resources (Java 7+ / 9+ 향상)
// AutoCloseable 구현 객체는 블록 종료 시 finally 없이 자동 close() 보장
try (BufferedReader br = new BufferedReader(new FileReader("data.txt"));
     Connection conn = dataSource.getConnection()) {
    String line = br.readLine();
    // 비즈니스 쿼리 실행
} catch (IOException | SQLException e) { // 다중 예외 처리
    log.error("I/O 또는 DB 예외 발생: ", e);
    throw new CustomBusinessException("작업 실패", e);
}

// [2] 사용자 정의 비즈니스 예외 (Unchecked 예외 상속 권장)
public class ResourceNotFoundException extends RuntimeException {
    public ResourceNotFoundException(String message) {
        super(message);
    }
    public ResourceNotFoundException(String message, Throwable cause) {
        super(message, cause);
    }
}
```

## 10. 파일 I/O & 현대적 NIO.2 (Files & Path)
```java
import java.nio.file.*;

Path path = Path.of("logs", "app.log"); // Java 11+ Path.of()

// 1. 파일 전체를 문자열로 읽기 & 쓰기 (Java 11+)
String content = Files.readString(path, StandardCharsets.UTF_8);
Files.writeString(Path.of("output.txt"), "새 내용", StandardOpenOption.CREATE, StandardOpenOption.APPEND);

// 2. 대용량 파일 한 줄씩 스트림으로 처리 (메모리 효율적)
try (var lines = Files.lines(path)) {
    lines.filter(line -> line.contains("ERROR"))
         .forEach(System.out::println);
}

// 3. 디렉토리 검사 및 생성
if (!Files.exists(path)) {
    Files.createDirectories(path.getParent());
}
```

## 11. 인터페이스 & 객체지향 설계 (Interface Evolution)
```java
public interface PaymentGateway {
    // 1. 추상 메서드 (반드시 구현 필요)
    PaymentResult pay(int amount);

    // 2. 디폴트 메서드 (default - 하위 호환성 보장 및 공통 로직 제공)
    default void sendReceipt(String email, int amount) {
        System.out.println("영수증 발송 to " + email + ": " + amount + "원");
    }

    // 3. 정적 유틸리티 메서드 (static)
    static boolean validateAmount(int amount) {
        return amount > 0;
    }

    // 4. 비공개 메서드 (private - Java 9+ 디폴트 메서드 내부 중복 로직 캡슐화)
    private void logTransaction(String type) {
        System.out.println("[LOG] 트랜잭션: " + type);
    }
}
```

## 12. 실무 JVM 튜닝 & 메모리 구조 (JVM Performance & Flags)
```text
# [1] JVM 메모리 핵심 영역
1. Heap Area:
   - 모든 객체(인스턴스)가 할당되는 영역
   - Young Generation (Eden, S0, S1) + Old Generation
2. Metaspace (Java 8+):
   - 클래스 메타데이터 저장 (네이티브 메모리 사용, PermGen 대체)
3. JVM Stack:
   - 각 스레드별 메서드 호출 프레임, 지역 변수 저장

# [2] 실무 필수 JVM 시작 옵션 (컨테이너/도커 환경)
java -server \
  -XX:+UseG1GC \                           # G1GC 기본 가비지 컬렉터 (지연시간 최소화)
  -XX:MaxRAMPercentage=75.0 \              # 컨테이너 메모리의 75%를 힙으로 자동 할당
  -XX:+UseContainerSupport \               # 도커 cgroup 메모리 제한 인식
  -XX:+HeapDumpOnOutOfMemoryError \        # OOM 발생 시 힙 덤프 자동 생성
  -XX:HeapDumpPath=/var/log/heapdump.hprof \
  -Dfile.encoding=UTF-8 \                  # UTF-8 파일 인코딩 강제
  -jar app.jar
```
💬
Java 치트시트

의견 및 질문

댓글 수정

댓글 삭제
