Java 8~21 버전별 차이점

✅ Java 8~21 버전별 차이점

https://www.java.com/releases/

JDK Releases

 

Java 8 (2014년 출시)

Java 8은 Java 언어에 큰 변화를 가져온 버전으로, 이후의 많은 기능들이 Java 8의 기능에 기반하고 있습니다.

• 32비트를 지원하는 공식적인 마지막 버전
• 람다 표현식 (Lambda Expressions): 함수형 프로그래밍을 도입하여 코드 간결화.
• 스트림 API (Stream API): 컬렉션 데이터를 처리하기 위한 선언형 API로, 필터링, 매핑, 축소(reduction) 등의 작업을 더 쉽게 수행.
• 인터페이스의 디폴트 메서드 (Default Methods): 인터페이스에 메서드 구현을 제공할 수 있도록 허용.
• Optional 클래스: NullPointerException 방지를 위해 사용되는 객체 래핑 클래스.
• 새로운 날짜 및 시간 API: java.time 패키지를 통해 더 나은 날짜 및 시간 처리를 제공.
• Perm Gem 영역삭제 (참고 : https://johngrib.github.io/wiki/java8-why-permgen-removed/)

1. 람다표현식

public class ExampleLambda {
	public static void main(String[] args) {
    	List<String> names = Arrays.asList("Park", "Kim", "Choi", "Lee");
        
        // 람다 표현식
        names.forEach(name -> System.out.println(name));
    }
}

2. 스트림API

public class ExampleStream {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 스트림을 이용한 필터링과 출력
        numbers.stream()
               .filter(n -> n % 2 == 0) // 짝수만 필터링
               .forEach(System.out::println);
    }
}

3. 인터페이스의 디폴트 메소드

interface MyInterface {
    default void defaultMethod() {
        System.out.println("This is a default method");
    }
}

public class DefaultMethodExample implements MyInterface {
    public static void main(String[] args) {
        DefaultMethodExample obj = new DefaultMethodExample();
        obj.defaultMethod(); // 디폴트 메소드 호출
    }
}

4. 새로운 날짜와 시간 API

public class ExampleDateTime {
    public static void main(String[] args) {
        LocalDate date = LocalDate.now();
        System.out.println("현재 날짜: " + date);

        LocalTime time = LocalTime.now();
        System.out.println("현재 시간: " + time);

        LocalDateTime dateTime = LocalDateTime.now();
        System.out.println("현재 날짜와 시간: " + dateTime);

        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String formattedDateTime = dateTime.format(formatter);
        System.out.println("형식화된 날짜와 시간: " + formattedDateTime);
    }
}

5. Optional클래스

public class ExampleOptional {
    public static void main(String[] args) {
        String name = "John";
        Optional<String> optionalName = Optional.ofNullable(name);
        
        System.out.println("이름 길이: " + optionalName.map(String::length).orElse(0));
        
        String nullName = null;
        Optional<String> optionalNullName = Optional.ofNullable(nullName);
        
        System.out.println("Null 이름 길이: " + optionalNullName.map(String::length).orElse(0));
    }
}

Java 9 (2017년 출시)

Java 9에서는 주요한 시스템적인 변화가 있었으며, 특히 모듈 시스템 도입이 큰 변화였습니다.

• 모듈 시스템 (Project Jigsaw): 대규모 애플리케이션을 모듈화할 수 있는 module-info.java 도입.
• JShell: 인터랙티브한 REPL(Read-Eval-Print Loop) 도구로, Java 코드를 바로 실행할 수 있게 함.
• 스트림 API 개선: takeWhile(), dropWhile(), iterate() 등의 메서드 추가.
• HTTP/2 클라이언트: 비동기 HTTP/2 호출을 지원하는 새 HTTP 클라이언트 API 도입.

1. 모듈 시스템

// module-info.java 파일을 프로젝트 루트에 생성
module mymodule {
    exports com.example.mymodule;
}

// 모듈사용예시
package com.example.mymodule;

public class MyModuleClass {
    public static void sayHello() {
        System.out.println("Hello from mymodule!");
    }
}

// 모듈을 통해서 서로 다른 패키지 간 의존성을 관리하고 접근 범위를 제어할수 있습니다.

2. 인터페이스의 private메소드

- Java9부터 인터페이스에 private메소드를 정의할수 있어서 코드 재사용이 더 용이해짐

interface MyInterface {
    default void method1() {
        System.out.println("Method 1");
        commonMethod();
    }

    default void method2() {
        System.out.println("Method 2");
        commonMethod();
    }

    // private 메소드 정의
    private void commonMethod() {
        System.out.println("This is a common method");
    }
}

public class PrivateMethodInInterfaceExample implements MyInterface {
    public static void main(String[] args) {
        PrivateMethodInInterfaceExample obj = new PrivateMethodInInterfaceExample();
        obj.method1();
        obj.method2();
    }
}

3. Stream API 개선

- Java 9에서는 takeWhile, dropWhile, iterate 등의 새로운 메소드가 Stream API에 추가되었습니다.

public class StreamAPIExample {
    public static void main(String[] args) {
        // takeWhile 예제
        Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
              .takeWhile(n -> n < 5) // 조건이 true인 동안만 요소를 가져옴
              .forEach(System.out::println);

        // dropWhile 예제
        Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
              .dropWhile(n -> n < 5) // 조건이 true인 동안은 건너뛰고 나머지를 가져옴
              .forEach(System.out::println);
    }
}

4. Optional 클래스 개선

- ifPresentOrElse, or, stream 등의 새로운 메소드가 추가

public class OptionalExample {
    public static void main(String[] args) {
        Optional<String> optionalValue = Optional.of("Hello");

        // ifPresentOrElse 메소드
        optionalValue.ifPresentOrElse(
            System.out::println, 
            () -> System.out.println("Value is absent")
        );

        // stream 메소드
        optionalValue.stream()
                     .forEach(System.out::println);
    }
}

5. try-with-resources 개선

public class TryWithResourcesExample {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader("test.txt"));

        // 이미 선언된 리소스를 try-with-resources에서 사용
        try (reader) {
            System.out.println(reader.readLine());
        }
    }
}

 

Java 10 (2018년 출시)

Java 10은 짧은 릴리스 주기로 제공되었으며, 주로 성능 향상 및 개발자 경험 개선에 초점을 맞췄습니다.

• 지역 변수 타입 추론 (var): 컴파일러가 자동으로 변수 타입을 추론하여 개발자가 명시적으로 타입을 선언할 필요가 없음.
• Garbage Collector 개선: G1 GC를 기본 GC로 지정하고 성능 최적화.

1. var키워드를 통한 지역변수 타입 추론

public class ExampleVar {
    public static void main(String[] args) {
        // var 키워드를 사용하여 타입 추론
        var message = "Hello, Java 10!";
        System.out.println(message);

        var numbers = List.of(1, 2, 3, 4, 5);
        System.out.println("List: " + numbers);

        var list = new ArrayList<String>();
        list.add("Java");
        list.add("10");
        System.out.println("ArrayList: " + list);
    }
}

2. List.copyOf(), Set.copyOf(), Map.copyOf() 메소드

- 컬렉션을 복사하여 불변 컬렉션을 생성하는 메소드가 추가

public class CopyOfExample {
    public static void main(String[] args) {
        // 기존 리스트 복사하여 불변 리스트 생성
        List<Integer> originalList = List.of(1, 2, 3);
        List<Integer> copyList = List.copyOf(originalList);
        System.out.println("List.copyOf: " + copyList);

        // 기존 셋 복사하여 불변 셋 생성
        Set<String> originalSet = Set.of("A", "B", "C");
        Set<String> copySet = Set.copyOf(originalSet);
        System.out.println("Set.copyOf: " + copySet);

        // 기존 맵 복사하여 불변 맵 생성
        Map<String, Integer> originalMap = Map.of("one", 1, "two", 2);
        Map<String, Integer> copyMap = Map.copyOf(originalMap);
        System.out.println("Map.copyOf: " + copyMap);
    }
}

3. Optional.orElseThrow() 메소드

public class OptionalExample {
    public static void main(String[] args) {
        Optional<String> optional = Optional.of("Hello, Java 10!");

        // 값이 없을 때 NoSuchElementException을 던짐
        String value = optional.orElseThrow();
        System.out.println(value);
    }
}

4. Collectors.toUnmodifiableList(), Collectors.toUnmodifiableSet(), Collectors.toUnmodifiableMap()

- Java 10에서는 스트림 처리 중 결과를 불변 컬렉션으로 수집하는 새로운 Collectors 메소드가 추가되었습니다. 이를 통해 수집된 컬렉션을 변경할 수 없도록 할 수 있습니다.

public class UnmodifiableCollectorsExample {
    public static void main(String[] args) {
        // 스트림을 불변 리스트로 수집
        List<String> unmodifiableList = Stream.of("A", "B", "C")
                                              .collect(Collectors.toUnmodifiableList());

        System.out.println("Unmodifiable List: " + unmodifiableList);

        // 리스트에 요소를 추가하려고 하면 UnsupportedOperationException 발생
        // unmodifiableList.add("D"); // 실행 시 예외 발생
    }
}

5. G1 가비지 컬렉터의 향상된 메모리 관리

 - G1 가비지 컬렉터가 기본 가비지 컬렉터로 설정되었으며, 전체 힙 영역을 동적으로 할당하는 기능이 추가되었습니다. 이로 인해 메모리 사용이 더욱 효율적이게 되었습니다.

 

Java 11 (2018년 출시, LTS)

Java 11은 장기 지원(Long-Term Support, LTS) 버전으로, 안정성과 기능을 제공하여 많은 기업에서 널리 사용됩니다.

• Open JDK와 Oracle JDK 통합
• 람다 지역 변수 사용 방법 변경 (var)
• 새로운 HTTP 클라이언트 API (HTTP/2 지원): HTTP/2 및 WebSocket을 지원하는 새 클라이언트 API가 정식으로 도입됨.
  - 버전11 부터 Java Http Client API는 최신 HTTP 표준 클라이언트를 구현하여 동기 및 비동기 프로그래밍 모델인 HTTP/1.1 및 HTTP/2를 지원함
• 새로운 String 메서드: isBlank(), lines(), repeat(), strip() 등의 유용한 String 메서드 추가.
• 표준화된 런타임 로드 가능성: Java 런타임에서 dynamic 클래스 파일을 로드할 수 있는 기능 추가.
• 응용 프로그램의 일부로 포함할 수 있는 Java 런타임: 기존의 java --add-modules로 여러 모듈을 조합 가능.

1. var를 사용한 람다 표현식의 지역 변수 타입 추론

public class LambdaVarExample {
    public static void main(String[] args) {
        BiFunction<Integer, Integer, Integer> add = (var a, var b) -> a + b;
        System.out.println(add.apply(10, 20));  // 출력: 30
    }
}

2. 새로운 String 메소드

public class StringMethodsExample {
    public static void main(String[] args) {
        String str = "  Hello Java 11!  ";

        // isBlank() 메소드
        System.out.println("".isBlank());  // 출력: true

        // strip() 메소드
        System.out.println("[" + str.strip() + "]");  // 출력: [Hello Java 11!]

        // lines() 메소드
        String multiLineStr = "Hello\nJava 11\n!";
        multiLineStr.lines().forEach(System.out::println);  
        // 출력:
        // Hello
        // Java 11
        // !

        // repeat() 메소드
        String repeated = "Hello ".repeat(3);
        System.out.println(repeated);  // 출력: Hello Hello Hello 
    }
}

3. HTTP Client 표준화

public class HttpClientExample {
    public static void main(String[] args) throws IOException, InterruptedException {
        // HttpClient 생성
        HttpClient client = HttpClient.newHttpClient();

        // 요청 생성
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://postman-echo.com/get"))
                .build();

        // 응답 받기
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

        // 응답 내용 출력
        System.out.println(response.body());
    }
}

4. 파일 읽기 및 쓰기 간소화

public class FileReadWriteExample {
    public static void main(String[] args) throws IOException {
        Path filePath = Path.of("example.txt");

        // 파일에 문자열 쓰기
        Files.writeString(filePath, "Hello, Java 11!");

        // 파일에서 문자열 읽기
        String content = Files.readString(filePath);
        System.out.println(content);  // 출력: Hello, Java 11!
    }
}

5. Optional 클래스의 isEmpty() 메소드 추가

public class OptionalExample {
    public static void main(String[] args) {
        Optional<String> optional = Optional.ofNullable(null);

        // isEmpty() 메소드 사용
        if (optional.isEmpty()) {
            System.out.println("Optional is empty!");  // 출력: Optional is empty!
        }
    }
}

6. Java EE와 CORBA 모듈 제거

- 11에서는 자바 EE 및 CORBA 관련 모듈이 더 이상 포함되지 않으며, 자바 스크립트 엔진 사용도 중단되었습니다. 이런 모듈들은 자주 사용되지 않으며, 필요할 경우 외부 라이브러리로 대체 가능

Java 12 (2019년 출시)

Java 12는 성능 및 새로운 기능들을 실험적으로 도입한 버전입니다.

• Switch Expressions (미리보기 기능): switch 문을 표현식으로 사용 가능.
• Garbage Collector 개선: G1 GC에 대한 성능 개선 및 Shenandoah GC 추가.

1. switch 표현식 (Switch Expressions) - 프리뷰 기능

public class SwitchExpressionExample {
    public static void main(String[] args) {
        int day = 2;

        // Java 12의 switch 표현식
        String dayName = switch (day) {
            case 1 -> "Sunday";
            case 2 -> "Monday";
            case 3 -> "Tuesday";
            case 4 -> "Wednesday";
            case 5 -> "Thursday";
            case 6 -> "Friday";
            case 7 -> "Saturday";
            default -> throw new IllegalArgumentException("Invalid day: " + day);
        };

        System.out.println("Day " + day + " is " + dayName);
    }
}

2. Collectors.teeing() 메소드

public class TeeingCollectorExample {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 평균과 합을 동시에 계산
        var result = numbers.stream()
            .collect(Collectors.teeing(
                Collectors.summingInt(Integer::intValue),
                Collectors.averagingInt(Integer::intValue),
                (sum, avg) -> "Sum: " + sum + ", Average: " + avg
            ));

        System.out.println(result);  // 출력: Sum: 55, Average: 5.5
    }
}

3. 새로운 String 메소드 (indent, transform)

public class StringMethodsExample {
    public static void main(String[] args) {
        String text = "Hello\nJava 12!";

        // indent() 메소드
        String indented = text.indent(4);
        System.out.println("Indented Text: ");
        System.out.println(indented);

        // transform() 메소드
        String transformed = text.transform(str -> str.toUpperCase());
        System.out.println("Transformed Text: " + transformed);  // 출력: HELLO\nJAVA 12!
    }
}

4. 파일 및 프로세스 API 개선

public class FileMismatchExample {
    public static void main(String[] args) throws IOException {
        Path file1 = Files.writeString(Files.createTempFile("file1", ".txt"), "Hello Java 12");
        Path file2 = Files.writeString(Files.createTempFile("file2", ".txt"), "Hello Java 11");

        // 두 파일의 불일치 위치 찾기
        long mismatch = Files.mismatch(file1, file2);
        System.out.println("Mismatch at byte position: " + mismatch);  // 출력: Mismatch at byte position: 9
    }
}

5. Shenandoah 가비지 컬렉터

- 새로운 가비지 컬렉터인 Shenandoah가 실험적으로 도입되었습니다. Shenandoah는 짧은 GC 지연 시간에 중점을 둔 가비지 컬렉터입니다. 이 예제는 Shenandoah GC를 직접 보여주지 않지만, GC를 활성화하는 방법은 다음과 같습니다.

6. JVM 개선 사항

- JVM에 몇 가지 중요한 개선 사항이 추가되었습니다. 그 중 하나는 JEP 346: Promptly Return Unused Committed Memory입니다. 이 기능은 JVM이 더 이상 사용하지 않는 메모리를 시스템에 빠르게 반환할 수 있게 해줍니다. 이 기능은 특히 메모리 효율성을 높이는데 유용합니다

Java 13 (2019년 출시)

Java 13은 간단한 개선 사항들을 도입했습니다.

• 텍스트 블록 (Text Blocks, 미리보기): 여러 줄의 문자열을 더욱 가독성 있게 작성할 수 있는 기능.
• Switch Expressions (미리보기): Switch 표현식이 더욱 간결하게 개선됨.

1. 텍스트 블록 (Text Blocks) - 프리뷰 기능

public class TextBlockExample {
    public static void main(String[] args) {
        String textBlock = """
                Hello, Java 13!
                This is a text block.
                It makes multi-line strings easier to write.
                """;

        System.out.println(textBlock);
    }
}

2. switch 표현식의 정식 도입

public class SwitchExpressionExample {
    public static void main(String[] args) {
        int day = 2;

        // Java 13의 switch 표현식
        String dayName = switch (day) {
            case 1 -> "Sunday";
            case 2 -> "Monday";
            case 3 -> "Tuesday";
            case 4 -> "Wednesday";
            case 5 -> "Thursday";
            case 6 -> "Friday";
            case 7 -> "Saturday";
            default -> throw new IllegalArgumentException("Invalid day: " + day);
        };

        System.out.println("Day " + day + " is " + dayName);
    }
}

3. yield를 사용한 switch 표현식

public class YieldInSwitchExample {
    public static void main(String[] args) {
        int score = 85;

        // Java 13의 switch 표현식에서 yield 사용
        String grade = switch (score / 10) {
            case 10, 9 -> "A";
            case 8 -> "B";
            case 7 -> "C";
            case 6 -> "D";
            default -> {
                // 여러 줄의 복잡한 로직이 있을 때 yield 사용 가능
                System.out.println("Failing grade.");
                yield "F";
            }
        };

        System.out.println("Grade: " + grade);  // 출력: Grade: B
    }
}

4. ZGC (Z Garbage Collector) 개선
5. 힙 영역 확장 (Dynamic CDS Archives)

Java 14 (2020년 출시)

Java 14는 생산성 향상을 위한 몇 가지 흥미로운 기능을 도입했습니다.

• Pattern Matching for instanceof (미리보기): instanceof와 타입 캐스팅을 결합하여 코드 간소화.
• Record 타입 (미리보기): 불변 데이터 구조를 간결하게 정의할 수 있는 Record 타입 추가.
• NPE 개선: NullPointerException 발생 시 더 구체적인 정보를 제공하도록 개선.

 

1. switch 표현식의 개선 (Switch Expressions) - 정식 도입

- switch 표현식이 정식 기능으로 도입되었습니다. 이 기능은 yield를 사용하여 결과를 반환할 수 있으며, 기존의 switch 문보다 간결한 코드를 작성할 수 있습니다.

2. NullPointerException의 상세 메시지 개선

- NullPointerException의 메시지를 더 상세하게 표시할 수 있게 되었습니다. 이제 어디에서 null이 발생했는지 정확한 정보를 얻을 수 있습니다.

3. 레코드 (Records) - 프리뷰 기능

// 레코드 정의
public record Person(String name, int age) {}

public class RecordExample {
    public static void main(String[] args) {
        // 레코드 인스턴스 생성
        Person person = new Person("John", 25);

        // 자동 생성된 메소드 사용
        System.out.println(person.name());  // 출력: John
        System.out.println(person.age());   // 출력: 25
        System.out.println(person);         // 출력: Person[name=John, age=25]
    }
}

4. 패턴 매칭을 이용한 instanceof

- instanceof 구문에서 타입 캐스팅을 더 간결하게 할 수 있는 패턴 매칭 기능이 추가되었습니다. 이제 instanceof로 타입을 확인한 후, 바로 해당 타입으로 변환할 수 있습니다.

public class InstanceofPatternMatchingExample {
    public static void main(String[] args) {
        Object obj = "Hello, Java 14!";

        // 패턴 매칭을 사용한 instanceof
        if (obj instanceof String s) {
            System.out.println(s.toUpperCase());  // 출력: HELLO, JAVA 14!
        }
    }
}

5. helpful NullPointerExceptions 옵션

- NullPointerException에 대한 유용한 정보가 포함된 상세 메시지를 제공하는 helpful NullPointerExceptions 옵션이 추가되었습니다. 이를 통해 디버깅이 훨씬 쉬워집니다. JVM을 실행할 때 다음과 같은 옵션을 추가할 수 있습니다.

java -XX:+ShowCodeDetailsInExceptionMessages MyApp.jar

6. JEP 367: ZGC on macOS and Windows

- ZGC(Z Garbage Collector)가 macOS와 Windows에서도 사용 가능하게 되었습니다. ZGC는 매우 짧은 지연 시간으로 동작하는 가비지 컬렉터입니다. 예제 코드로는 직접 확인하기 어렵지만, ZGC를 사용하는 방식은 다음과 같습니다

java -XX:+UseZGC -Xmx4g -Xms4g MyApp.jar

Java 15 (2020년 출시)

Java 15는 여러 실험적 기능들을 완성시키는 중요한 버전입니다.

• 텍스트 블록 (Text Blocks, 정식): 여러 줄 문자열을 쉽게 작성할 수 있도록 하는 기능이 정식으로 도입됨.
• Sealed 클래스 (미리보기): 클래스 계층을 제한하는 기능으로, 특정 클래스만 상속할 수 있도록 허용.
• Hidden 클래스: 런타임에서 생성되고 이후 다시 사용되지 않는 클래스들을 위한 기능.

1. 레코드 (Records) - 개선

2. Sealed Classes (봉인된 클래스) - 프리뷰 기능

// 봉인된 클래스 정의
public sealed class Shape permits Circle, Square {}

final class Circle extends Shape {
    double radius;
}

final class Square extends Shape {
    double side;
}

public class SealedClassExample {
    public static void main(String[] args) {
        Shape shape1 = new Circle();
        Shape shape2 = new Square();
        System.out.println("Shape1 is a " + shape1.getClass().getSimpleName());
        System.out.println("Shape2 is a " + shape2.getClass().getSimpleName());
    }
}

3. 텍스트 블록 (Text Blocks) - 정식 도입

4. 패턴 매칭을 이용한 instanceof의 개선

5. 숨겨진 클래스 (Hidden Classes)

- **숨겨진 클래스 (Hidden Classes)**라는 기능이 추가되었습니다. 이 클래스는 런타임에만 사용되고, 직접적으로 참조할 수 없는 클래스로, 주로 프레임워크에서 동적으로 클래스를 생성할 때 유용합니다. 예제 코드로는 다소 복잡하며, 프레임워크 수준에서 주로 사용됩니다.

Java 16 (2021년 출시)

Java 16은 성능과 생산성 향상에 초점을 맞췄습니다.

• Record (정식): Record 타입이 정식 기능으로 도입되어 불변 객체의 선언이 간소화됨.
• 패턴 매칭 for instanceof (정식): instanceof와 함께 사용 가능한 패턴 매칭이 정식으로 도입됨.
• Stream.toList(): 스트림을 리스트로 쉽게 변환할 수 있는 새로운 메서드 추가.

1. 레코드 (Records) - 정식 기능

2. 패턴 매칭을 이용한 instanceof - 정식 도입

3. Stream API 개선

4. 프록시의 직렬화 기능 개선

5. Vector API (Incubator)

public class VectorAPIExample {
    public static void main(String[] args) {
        // Int 벡터 연산 예제
        VectorSpecies<Integer> SPECIES = IntVector.SPECIES_256;
        int[] a = {1, 2, 3, 4, 5, 6, 7, 8};
        int[] b = {1, 2, 3, 4, 5, 6, 7, 8};
        int[] c = new int[8];

        var av = IntVector.fromArray(SPECIES, a, 0);
        var bv = IntVector.fromArray(SPECIES, b, 0);
        var cv = av.add(bv);
        cv.intoArray(c, 0);

        for (int value : c) {
            System.out.println(value);  // 출력: 2 4 6 8 10 12 14 16
        }
    }
}

6. Sealed Classes (봉인된 클래스) - 프리뷰 기능 (계속 개선)

 

Java 17 (2021년 출시, LTS)

Java 17은 Java 11 이후의 두 번째 장기 지원(LTS) 버전으로, 많은 새로운 기능과 안정성 개선이 포함되었습니다.

• Sealed 클래스 (정식): 서브클래스를 제한하는 기능이 정식으로 도입됨.
• Pattern Matching for switch (미리보기): switch 문에서 패턴 매칭을 사용할 수 있음.
• Foreign Function & Memory API (미리보기): 외부 메모리 접근과 외부 함수 호출을 보다 효율적으로 할 수 있는 API 추가.

1. 패턴 매칭을 이용한 switch 표현식

public class PatternMatchingSwitchExample {
    public static void main(String[] args) {
        Object obj = "Hello, Java 17!";

        // 패턴 매칭을 이용한 switch 표현식
        String result = switch (obj) {
            case Integer i -> "Integer: " + i;
            case String s -> "String: " + s;
            case null -> "Null value";
            default -> "Unknown type";
        };

        System.out.println(result);  // 출력: String: Hello, Java 17!
    }
}

2. 레코드 (Records)와 Sealed Classes의 조합

public sealed interface Shape permits Circle, Rectangle {}

public record Circle(double radius) implements Shape {}

public record Rectangle(double width, double height) implements Shape {}

public class SealedRecordExample {
    public static void main(String[] args) {
        Shape shape = new Circle(5.0);

        String description = switch (shape) {
            case Circle c -> "Circle with radius: " + c.radius();
            case Rectangle r -> "Rectangle with width: " + r.width() + " and height: " + r.height();
        };

        System.out.println(description);  // 출력: Circle with radius: 5.0
    }
}

3. 강력한 Random구현

public class RandomExample {
    public static void main(String[] args) {
        // RandomGenerator 인터페이스를 이용한 랜덤 숫자 생성기
        RandomGenerator generator = RandomGeneratorFactory.of("Xoshiro256PlusPlus").create();

        for (int i = 0; i < 5; i++) {
            System.out.println(generator.nextInt(100));  // 0부터 100 사이의 난수 출력
        }
    }
}

Java 18 (2022년 출시)

Java 18은 주로 성능과 개발자 경험 향상에 초점을 맞춘 버전입니다.

• Simple Web Server: 간단한 개발 및 테스트용 웹 서버 추가.
• UTF-8 기본 문자 인코딩: 모든 플랫폼에서 UTF-8을 기본 인코딩으로 사용하도록 표준화.

1. Simple Web Server

public class SimpleWebServerExample {
    public static void main(String[] args) throws IOException {
        // HTTP 서버 생성
        HttpServer server = HttpServer.create(new InetSocketAddress(8080), 0);

        // 요청에 대해 간단한 응답 작성
        server.createContext("/", exchange -> {
            String response = "Hello, Java 18!";
            exchange.sendResponseHeaders(200, response.getBytes().length);
            exchange.getResponseBody().write(response.getBytes());
            exchange.close();
        });

        // 서버 시작
        server.start();
        System.out.println("Server started at http://localhost:8080");
    }
}

2. Code Snippets in JavaDoc (JEP 413)

/**
 * 이 클래스는 Java 18의 JavaDoc 코드 스니펫 기능을 보여줍니다.
 * {@snippet :
 *  // JavaDoc에 코드 예시 삽입
 *  System.out.println("Hello, JavaDoc Snippets!");
 * }
 */
public class JavadocSnippetExample {
    public static void main(String[] args) {
        System.out.println("Hello, Java 18!");
    }
}

Java 19 (2022년 출시)

Java 19는 새로운 기능을 실험적으로 도입했습니다.

• Virtual Threads (미리보기): Java의 동시성 모델을 개선하여 더 많은 스레드를 효율적으로 처리할 수 있도록 지원.
• Structured Concurrency (미리보기): 여러 스레드 작업을 구조화하여 처리하는 API.

Java 20 (2023년 출시)

Java 20에서는 주로 이전에 도입된 기능을 확장하거나 실험적 기능들을 개선했습니다.

• Virtual Threads (확장된 미리보기): 가벼운 스레드로 성능 최적화 및 개선.
• Pattern Matching for switch (확장된 미리보기): switch 문에서 더 강력한 패턴 매칭 가능.

Java 21 (2023년 출시, LTS)

Java 21은 새로운 LTS 버전으로 장기적으로 지원되며, 많은 주요 기능을 정식으로 도입했습니다.

• Virtual Threads (정식): 동시성 프로그래밍을 쉽게 할 수 있도록 돕는 가벼운 스레드 기능이 정식으로 추가됨.
• Pattern Matching for switch (정식): switch 문에서 더 복잡한 패턴 매칭이 가능하게 되었음.
• Record Patterns (정식): record와 함께 사용할 수 있는 패턴 매칭 지원.
• Sequenced Collections: 순서를 보장하는 새로운 컬렉션 인터페이스 도입.

1. Virtual Threads (가상 스레드) - 정식 기능

public class VirtualThreadExample {
    public static void main(String[] args) throws InterruptedException {
        // 가상 스레드를 사용하는 ExecutorService 생성
        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < 10; i++) {
                executor.submit(() -> {
                    System.out.println("Running on virtual thread: " + Thread.currentThread());
                });
            }
        }
    }
}

2. Pattern Matching for switch - 정식 기능

public class PatternMatchingSwitchExample {
    public static void main(String[] args) {
        Object obj = "Java 21";

        // 패턴 매칭을 사용하는 switch 표현식
        String result = switch (obj) {
            case Integer i -> "Integer: " + i;
            case String s -> "String: " + s.toUpperCase();
            case null -> "Null value";
            default -> "Unknown type";
        };

        System.out.println(result);  // 출력: String: JAVA 21
    }
}

3. Sequenced Collections

public class SequencedCollectionExample {
    public static void main(String[] args) {
        SequencedCollection<String> sequencedList = new LinkedList<>();
        sequencedList.addFirst("First");
        sequencedList.addLast("Last");

        System.out.println("First element: " + sequencedList.getFirst());
        System.out.println("Last element: " + sequencedList.getLast());
    }
}

4. String Templates - 프리뷰 기능

public class StringTemplateExample {
    public static void main(String[] args) {
        int age = 25;
        String name = "Alice";

        // 문자열 템플릿을 사용한 간결한 표현
        String result = STR."Hello, \{name}! You are \{age} years old.";
        System.out.println(result);  // 출력: Hello, Alice! You are 25 years old.
    }
}

5. Unnamed Classes and Instance Main Methods - 프리뷰 기능

public class MainExample {
    void main() {
        System.out.println("Instance Main Method");
    }

    public static void main(String[] args) {
        new MainExample().main();  // 출력: Instance Main Method
    }
}

6. Foreign Function & Memory API - 정식 기능

public class ForeignFunctionMemoryExample {
    public static void main(String[] args) {
        try (MemorySegment segment = MemorySegment.allocateNative(JAVA_INT)) {
            segment.set(JAVA_INT, 0, 42);
            int value = segment.get(JAVA_INT, 0);
            System.out.println("Value from native memory: " + value);  // 출력: 42
        }
    }
}

 

결론

• Java 8: 람다, 스트림 API, 새로운 날짜 및 시간 API 등.
• Java 9~10: 모듈 시스템과 var 타입 추론 등.
• Java 11: LTS 버전으로 HTTP 클라이언트 API와 새로운 String 메서드.
• Java 12~15: Switch 표현식, 텍스트 블록, 패턴 매칭 등의 실험적 기능.
• Java 16~17: Record와 Sealed 클래스 정식 도입, 패턴 매칭 기능 강화.
• Java 18~21: Virtual Threads, Pattern Matching for switch 등의 동시성 및 패턴 매칭 기능 개선.

각 버전마다 Java 언어와 런타임에 중요한 개선 사항들이 도입되었으며, 특히 Java 8, 11, 17, 21은 LTS 버전으로 장기적인 지원을 제공합니다.