Java 22 Preview Features Overview

Introduction

Java 22, released in March 2024, introduces several preview features, incubator APIs, and final features that enhance the language's capabilities. This comprehensive overview covers all the major features with detailed examples and practical use cases.

1. Structured Concurrency (Second Preview - JEP 462)

Structured Concurrency simplifies concurrent programming by treating groups of related tasks as single units of work.

Core Implementation

import java.util.concurrent.*; import jdk.incubator.concurrent.*; public class StructuredConcurrencyDemo { public static void main(String[] args) throws Exception { var demo = new StructuredConcurrencyDemo(); // Example 1: Basic structured concurrency demo.basicStructuredTask(); // Example 2: Error handling in structured concurrency demo.structuredConcurrencyWithErrorHandling(); // Example 3: Shutdown behavior demo.structuredConcurrencyShutdown(); } public void basicStructuredTask() throws Exception { try (var scope = new StructuredTaskScope.ShutdownOnFailure()) { // Fork multiple subtasks Supplier<String> userTask = scope.fork(() -> fetchUserData("user123")); Supplier<String> productTask = scope.fork(() -> fetchProductData("prod456")); Supplier<Integer> inventoryTask = scope.fork(() -> checkInventory("prod456")); // Join all tasks - this waits for all to complete or any to fail scope.join(); scope.throwIfFailed(); // Throws if any subtask failed // Combine results String user = userTask.get(); String product = productTask.get(); int inventory = inventoryTask.get(); System.out.printf("User: %s, Product: %s, Inventory: %d%n", user, product, inventory); } } public void structuredConcurrencyWithErrorHandling() { try (var scope = new StructuredTaskScope.ShutdownOnFailure()) { Supplier<String> successTask = scope.fork(() -> successfulTask()); Supplier<String> failingTask = scope.fork(() -> failingTask()); scope.join(); try { scope.throwIfFailed(); System.out.println("All tasks completed successfully"); } catch (ExecutionException e) { System.out.println("Task failed with: " + e.getCause().getMessage()); // Handle partial results if (successTask.state() == Future.State.SUCCESS) { System.out.println("Successful task result: " + successTask.get()); } } } catch (InterruptedException e) { Thread.currentThread().interrupt(); System.out.println("Operation interrupted"); } } public void structuredConcurrencyShutdown() throws Exception { try (var scope = new StructuredTaskScope.ShutdownOnFailure()) { Supplier<String> quickTask = scope.fork(() -> quickOperation()); Supplier<String> slowTask = scope.fork(() -> slowOperation()); // Simulate cancellation after timeout Thread.sleep(100); scope.shutdown(); // Cancels all unfinished tasks scope.join(); if (quickTask.state() == Future.State.SUCCESS) { System.out.println("Quick task completed: " + quickTask.get()); } if (slowTask.state() == Future.State.CANCELLED) { System.out.println("Slow task was cancelled"); } } } // Simulated service methods private String fetchUserData(String userId) throws InterruptedException { Thread.sleep(200); return "User: " + userId; } private String fetchProductData(String productId) throws InterruptedException { Thread.sleep(150); return "Product: " + productId; } private int checkInventory(String productId) throws InterruptedException { Thread.sleep(100); return 42; } private String successfulTask() throws InterruptedException { Thread.sleep(50); return "Success"; } private String failingTask() throws InterruptedException { Thread.sleep(50); throw new RuntimeException("Task failed intentionally"); } private String quickOperation() throws InterruptedException { Thread.sleep(50); return "Quick result"; } private String slowOperation() throws InterruptedException { Thread.sleep(1000); // This will be interrupted return "Slow result"; } }

Advanced Structured Concurrency Patterns

import java.util.*; import java.util.concurrent.*; import jdk.incubator.concurrent.*; public class AdvancedStructuredConcurrency { // Custom result collector scope public static class CollectingScope<T> extends StructuredTaskScope<T> { private final List<Supplier<T>> completedTasks = new ArrayList<>(); private final List<Throwable> exceptions = new ArrayList<>(); @Override protected void handleComplete(Future<T> future) { switch (future.state()) { case SUCCESS -> completedTasks.add(future); case FAILED -> exceptions.add(future.exception()); case CANCELLED -> {} // Ignore cancelled tasks } } public List<T> getResults() { return completedTasks.stream() .map(Supplier::get) .toList(); } public List<Throwable> getExceptions() { return Collections.unmodifiableList(exceptions); } } public void collectingScopeDemo() throws Exception { try (var scope = new CollectingScope<String>()) { // Fork multiple tasks with different outcomes scope.fork(() -> taskThatSucceeds("Task1")); scope.fork(() -> taskThatFails("Task2")); scope.fork(() -> taskThatSucceeds("Task3")); scope.join(); System.out.println("Successful results: " + scope.getResults()); System.out.println("Exceptions: " + scope.getExceptions().stream() .map(Throwable::getMessage) .toList()); } } // Batch processing with structured concurrency public <T, R> List<R> processBatch( List<T> items, Function<T, R> processor, int maxConcurrency) throws Exception { try (var scope = new StructuredTaskScope.ShutdownOnFailure()) { // Limit concurrency var futures = items.stream() .limit(maxConcurrency) .map(item -> scope.fork(() -> processor.apply(item))) .toList(); scope.join(); scope.throwIfFailed(); return futures.stream() .map(Supplier::get) .toList(); } } // Race between multiple services public String raceMultipleServices(List<Callable<String>> services) throws Exception { try (var scope = new StructuredTaskScope<String>()) { var futures = services.stream() .map(service -> scope.fork(service::call)) .toList(); scope.join(); // Return the first successful result return futures.stream() .filter(future -> future.state() == Future.State.SUCCESS) .findFirst() .map(Supplier::get) .orElseThrow(() -> new RuntimeException("All services failed")); } } private String taskThatSucceeds(String name) { return name + "-success"; } private String taskThatFails(String name) { throw new RuntimeException(name + "-failed"); } }

2. Scoped Values (Second Preview - JEP 464)

Scoped Values provide a way to share immutable data within and across threads, replacing ThreadLocal for many use cases.

Basic Usage

import jdk.incubator.concurrent.*; public class ScopedValuesDemo { // Define scoped values private static final ScopedValue<String> CURRENT_USER = ScopedValue.newInstance(); private static final ScopedValue<Locale> USER_LOCALE = ScopedValue.newInstance(); private static final ScopedValue<Map<String, String>> REQUEST_CONTEXT = ScopedValue.newInstance(); public static void main(String[] args) throws Exception { var demo = new ScopedValuesDemo(); // Example 1: Basic scoped value usage demo.basicScopedValue(); // Example 2: Nested scopes demo.nestedScopes(); // Example 3: With structured concurrency demo.scopedValuesWithConcurrency(); // Example 4: Request context simulation demo.requestContextExample(); } public void basicScopedValue() { // Bind value for the scope ScopedValue.where(CURRENT_USER, "alice") .run(() -> { System.out.println("Current user: " + CURRENT_USER.get()); processUserRequest(); }); // Outside the scope, the value is unbound try { System.out.println(CURRENT_USER.get()); } catch (IllegalStateException e) { System.out.println("Correctly caught: " + e.getMessage()); } } public void nestedScopes() { ScopedValue.where(CURRENT_USER, "bob") .run(() -> { System.out.println("Outer scope user: " + CURRENT_USER.get()); // Nested scope with different value ScopedValue.where(CURRENT_USER, "charlie") .run(() -> { System.out.println("Inner scope user: " + CURRENT_USER.get()); }); // Back to original value System.out.println("Back to outer scope user: " + CURRENT_USER.get()); }); } public void scopedValuesWithConcurrency() throws Exception { ScopedValue.where(CURRENT_USER, "main-thread-user") .where(USER_LOCALE, Locale.US) .run(() -> { try (var scope = new StructuredTaskScope.ShutdownOnFailure()) { // Fork tasks that inherit scoped values var task1 = scope.fork(() -> { System.out.println("Task 1 user: " + CURRENT_USER.get()); System.out.println("Task 1 locale: " + USER_LOCALE.get()); return "task1-result"; }); var task2 = scope.fork(() -> { System.out.println("Task 2 user: " + CURRENT_USER.get()); System.out.println("Task 2 locale: " + USER_LOCALE.get()); return "task2-result"; }); scope.join(); scope.throwIfFailed(); System.out.println("Results: " + task1.get() + ", " + task2.get()); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }); } public void requestContextExample() { Map<String, String> context = Map.of( "requestId", "req-12345", "sessionId", "sess-67890", "userAgent", "Mozilla/5.0" ); ScopedValue.where(REQUEST_CONTEXT, context) .where(CURRENT_USER, "api-user") .run(() -> { handleApiRequest(); performDatabaseOperation(); logAuditEvent(); }); } private void processUserRequest() { System.out.println("Processing request for: " + CURRENT_USER.get()); // Access scoped value in called methods validateUser(); checkPermissions(); } private void validateUser() { String user = CURRENT_USER.get(); System.out.println("Validating user: " + user); } private void checkPermissions() { String user = CURRENT_USER.get(); System.out.println("Checking permissions for: " + user); } private void handleApiRequest() { Map<String, String> context = REQUEST_CONTEXT.get(); String user = CURRENT_USER.get(); System.out.printf("Handling API request - User: %s, RequestId: %s%n", user, context.get("requestId")); } private void performDatabaseOperation() { Map<String, String> context = REQUEST_CONTEXT.get(); System.out.println("DB operation for request: " + context.get("requestId")); } private void logAuditEvent() { Map<String, String> context = REQUEST_CONTEXT.get(); String user = CURRENT_USER.get(); System.out.printf("Audit event - User: %s, Session: %s%n", user, context.get("sessionId")); } }

Advanced Scoped Values Patterns

import jdk.incubator.concurrent.*; import java.util.*; import java.util.concurrent.*; public class AdvancedScopedValues { private static final ScopedValue<Transaction> CURRENT_TRANSACTION = ScopedValue.newInstance(); private static final ScopedValue<SecurityContext> SECURITY_CONTEXT = ScopedValue.newInstance(); private static final ScopedValue<Map<String, Object>> FEATURE_FLAGS = ScopedValue.newInstance(); // Transaction management with scoped values public static class Transaction { private final String id; private final List<String> operations = new ArrayList<>(); private boolean committed = false; public Transaction(String id) { this.id = id; } public void addOperation(String operation) { operations.add(operation); } public void commit() { this.committed = true; System.out.println("Transaction " + id + " committed with operations: " + operations); } public void rollback() { System.out.println("Transaction " + id + " rolled back"); } } public static class SecurityContext { private final String userId; private final Set<String> roles; private final String tenantId; public SecurityContext(String userId, Set<String> roles, String tenantId) { this.userId = userId; this.roles = Set.copyOf(roles); this.tenantId = tenantId; } public boolean hasRole(String role) { return roles.contains(role); } public String getUserId() { return userId; } public Set<String> getRoles() { return roles; } public String getTenantId() { return tenantId; } } public void transactionExample() { Transaction tx = new Transaction("tx-" + System.currentTimeMillis()); ScopedValue.where(CURRENT_TRANSACTION, tx) .run(() -> { try { performBusinessOperation(); tx.commit(); } catch (Exception e) { tx.rollback(); throw e; } }); } public void securityContextExample() { SecurityContext securityContext = new SecurityContext( "user123", Set.of("ADMIN", "USER"), "tenant-abc" ); ScopedValue.where(SECURITY_CONTEXT, securityContext) .run(() -> { accessSecureResource(); performAdminOperation(); }); } public void featureFlagsExample() { Map<String, Object> flags = Map.of( "new_ui_enabled", true, "experimental_feature", false, "max_records", 1000 ); ScopedValue.where(FEATURE_FLAGS, flags) .run(() -> { renderUI(); processData(); }); } // Method that requires transaction context private void performBusinessOperation() { Transaction tx = CURRENT_TRANSACTION.get(); tx.addOperation("update_user_profile"); tx.addOperation("send_notification"); System.out.println("Performing business operation in transaction: " + tx.id); } // Method that requires security context private void accessSecureResource() { SecurityContext context = SECURITY_CONTEXT.get(); if (!context.hasRole("USER")) { throw new SecurityException("Access denied"); } System.out.println("Accessing secure resource for user: " + context.getUserId()); } private void performAdminOperation() { SecurityContext context = SECURITY_CONTEXT.get(); if (!context.hasRole("ADMIN")) { throw new SecurityException("Admin access required"); } System.out.println("Performing admin operation"); } private void renderUI() { Map<String, Object> flags = FEATURE_FLAGS.get(); boolean newUIEnabled = (Boolean) flags.get("new_ui_enabled"); if (newUIEnabled) { System.out.println("Rendering new UI"); } else { System.out.println("Rendering legacy UI"); } } private void processData() { Map<String, Object> flags = FEATURE_FLAGS.get(); int maxRecords = (Integer) flags.get("max_records"); System.out.println("Processing data with max records: " + maxRecords); } // Cross-thread scoped value propagation public void crossThreadScopedValues() throws Exception { ScopedValue.where(CURRENT_USER, "parent-thread-user") .run(() -> { try (var scope = new StructuredTaskScope<String>()) { // Child threads inherit scoped values var task1 = scope.fork(() -> { String user = CURRENT_USER.get(); return "Task completed for user: " + user; }); var task2 = scope.fork(() -> { String user = CURRENT_USER.get(); return "Another task for user: " + user; }); scope.join(); System.out.println(task1.get()); System.out.println(task2.get()); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }); } }

3. String Templates (Second Preview - JEP 459)

String Templates provide a safer, more efficient way to compose strings than traditional concatenation or StringBuilder.

Basic String Templates

public class StringTemplatesDemo { public static void main(String[] args) { var demo = new StringTemplatesDemo(); // Example 1: Basic string templates demo.basicTemplates(); // Example 2: Expression templates demo.expressionTemplates(); // Example 3: Multiline templates demo.multilineTemplates(); // Example 4: Custom template processors demo.customTemplateProcessors(); // Example 5: SQL and HTML templates demo.safeTemplates(); } public void basicTemplates() { String name = "Alice"; int age = 30; // Basic string template String message = STR."Hello, my name is \{name} and I'm \{age} years old"; System.out.println(message); // Complex expressions in templates String complex = STR.""" Calculation result: - Name: \{name} - Age: \{age} - Next year: \{age + 1} - Length of name: \{name.length()} """; System.out.println(complex); } public void expressionTemplates() { // Mathematical expressions int x = 10, y = 20; String math = STR."\{x} + \{y} = \{x + y}"; System.out.println(math); // Method calls in templates List<String> items = List.of("apple", "banana", "cherry"); String listInfo = STR.""" List information: - Size: \{items.size()} - First item: \{items.getFirst()} - Contains 'banana': \{items.contains("banana")} """; System.out.println(listInfo); // Conditional expressions int score = 85; String grade = STR."Score: \{score}, Grade: \{(score >= 90) ? "A" : (score >= 80) ? "B" : "C"}"; System.out.println(grade); } public void multilineTemplates() { String className = "UserService"; String methodName = "getUser"; List<String> parameters = List.of("userId", "includeProfile"); // Generate code with multiline templates String code = STR.""" public class \{className} { public User \{methodName}(String userId, boolean includeProfile) { // Implementation here return userRepository.findById(userId) .map(user -> { if (includeProfile) { user.loadProfile(); } return user; }); } } """; System.out.println(code); // JSON generation String json = STR.""" { "user": { "name": "John Doe", "email": "[email protected]", "active": true, "roles": ["USER", "EDITOR"] } } """; System.out.println(json); } public void customTemplateProcessors() { // FMT processor for formatting String formatted = FMT.""" Formatted values: - Percentage: %.2f\{0.8567} - Currency: $%,.2f\{1234.56} - Padded number: %05d\{42} """; System.out.println(formatted); // Custom processor for validation StringTemplate.Processor<String, RuntimeException> validator = StringTemplate.Processor.of((StringTemplate st) -> { for (Object value : st.values()) { if (value instanceof String str && str.contains("'")) { throw new IllegalArgumentException("Invalid character in string: " + str); } } return st.interpolate(); }); try { String safe = validator."Safe string: \{"normal text"}"; System.out.println(safe); // This will throw an exception validator."Unsafe string: \{"text with ' quote"}"; } catch (IllegalArgumentException e) { System.out.println("Caught expected exception: " + e.getMessage()); } } public void safeTemplates() { // SQL template with custom processor StringTemplate.Processor<PreparedStatement, SQLException> SQL = StringTemplate.Processor.of((StringTemplate st) -> { String query = String.join("?", st.fragments()); PreparedStatement ps = createPreparedStatement(query); for (int i = 0; i < st.values().size(); i++) { ps.setObject(i + 1, st.values().get(i)); } return ps; }); // HTML template with escaping StringTemplate.Processor<String, RuntimeException> HTML = StringTemplate.Processor.of((StringTemplate st) -> { StringBuilder sb = new StringBuilder(); List<String> fragments = st.fragments(); List<Object> values = st.values(); for (int i = 0; i < fragments.size(); i++) { sb.append(fragments.get(i)); if (i < values.size()) { String escaped = escapeHtml(values.get(i).toString()); sb.append(escaped); } } return sb.toString(); }); try { String userInput = "<script>alert('xss')</script>"; String safeHtml = HTML.""" <div class="user-content"> \{userInput} </div> """; System.out.println("Safe HTML: " + safeHtml); } catch (Exception e) { System.out.println("HTML processing error: " + e.getMessage()); } } private String escapeHtml(String input) { return input.replace("&", "&amp;") .replace("<", "&lt;") .replace(">", "&gt;") .replace("\"", "&quot;") .replace("'", "&#39;"); } private PreparedStatement createPreparedStatement(String query) throws SQLException { // Mock implementation System.out.println("Creating prepared statement: " + query); return null; } }

Advanced String Template Processors

import java.util.*; import java.time.*; import java.util.regex.*; public class AdvancedStringTemplates { // JSON template processor public static final StringTemplate.Processor<JSONObject, RuntimeException> JSON = StringTemplate.Processor.of((StringTemplate st) -> { JSONObject json = new JSONObject(); List<String> fragments = st.fragments(); List<Object> values = st.values(); // Simple key-value parsing (for demonstration) for (int i = 0; i < fragments.size(); i++) { String fragment = fragments.get(i); // Extract key from fragment (simplified) String key = extractJsonKey(fragment); if (key != null && i < values.size()) { json.put(key, values.get(i)); } } return json; }); // Logging template processor public static final StringTemplate.Processor<Void, RuntimeException> LOG = StringTemplate.Processor.of((StringTemplate st) -> { String message = st.interpolate(); System.out.println(LocalDateTime.now() + " [INFO] " + message); return null; }); // Validation template processor public static final StringTemplate.Processor<String, IllegalArgumentException> VALIDATED = StringTemplate.Processor.of((StringTemplate st) -> { for (Object value : st.values()) { if (value == null) { throw new IllegalArgumentException("Null values not allowed"); } if (value instanceof String str && str.isBlank()) { throw new IllegalArgumentException("Empty strings not allowed"); } } return st.interpolate(); }); // Localization template processor public static class LocalizedProcessor implements StringTemplate.Processor<String, RuntimeException> { private final ResourceBundle bundle; public LocalizedProcessor(Locale locale) { this.bundle = ResourceBundle.getBundle("messages", locale); } @Override public String process(StringTemplate st) { StringBuilder result = new StringBuilder(); List<String> fragments = st.fragments(); List<Object> values = st.values(); for (int i = 0; i < fragments.size(); i++) { String fragment = fragments.get(i); // Look up translation String translated = bundle.getString(fragment.trim()); result.append(translated); if (i < values.size()) { result.append(values.get(i)); } } return result.toString(); } } public static void main(String[] args) { var demo = new AdvancedStringTemplates(); demo.jsonTemplates(); demo.loggingTemplates(); demo.validationTemplates(); demo.localizationTemplates(); } public void jsonTemplates() { String name = "John Doe"; int age = 30; boolean active = true; JSONObject userJson = JSON.""" { "name": "\{name}", "age": \{age}, "active": \{active}, "createdAt": "\{LocalDateTime.now()}" } """; System.out.println("Generated JSON: " + userJson); } public void loggingTemplates() { String userId = "user123"; String action = "login"; int duration = 150; LOG."User \{userId} performed action \{action} in \{duration}ms"; LOG."System health check - Memory: \{Runtime.getRuntime().freeMemory()} free"; } public void validationTemplates() { String validName = "Alice"; String emptyName = ""; try { String valid = VALIDATED."Hello, \{validName}!"; System.out.println("Valid: " + valid); String invalid = VALIDATED."Hello, \{emptyName}!"; } catch (IllegalArgumentException e) { System.out.println("Caught validation error: " + e.getMessage()); } } public void localizationTemplates() { LocalizedProcessor english = new LocalizedProcessor(Locale.ENGLISH); LocalizedProcessor french = new LocalizedProcessor(Locale.FRENCH); String name = "Pierre"; int count = 3; String englishMessage = english."greeting" + name + "welcome" + count + "messages"; String frenchMessage = french."greeting" + name + "welcome" + count + "messages"; System.out.println("English: " + englishMessage); System.out.println("French: " + frenchMessage); } private static String extractJsonKey(String fragment) { // Simplified key extraction - in real implementation, use proper parsing Pattern pattern = Pattern.compile("\"([^\"]+)\"\\s*:"); Matcher matcher = pattern.matcher(fragment); return matcher.find() ? matcher.group(1) : null; } // Mock JSONObject class for demonstration static class JSONObject { private final Map<String, Object> map = new HashMap<>(); public void put(String key, Object value) { map.put(key, value); } @Override public String toString() { return map.toString(); } } }

4. Implicitly Declared Classes and Instance Main Methods (Second Preview - JEP 463)

This feature simplifies Java for beginners by allowing more flexible class and method declarations.

Simplified Java Syntax

// Simple standalone file - HelloWorld.java void main() { System.out.println("Hello, World!"); } // With parameters void main(String[] args) { if (args.length > 0) { System.out.println("Hello, " + args[0] + "!"); } else { System.out.println("Hello, World!"); } } // With class fields and methods String message = "Welcome to Java!"; void main() { printMessage(); calculateSum(5, 3); } void printMessage() { System.out.println(message); } void calculateSum(int a, int b) { System.out.println(a + " + " + b + " = " + (a + b)); }

Advanced Examples

// Student Management System in simplified syntax import java.util.*; import java.time.*; // Implicit class with instance main List<Student> students = new ArrayList<>(); void main() { setupSampleData(); displayMenu(); } void setupSampleData() { students.add(new Student("Alice", "Johnson", LocalDate.of(2000, 5, 15), "Computer Science")); students.add(new Student("Bob", "Smith", LocalDate.of(1999, 8, 22), "Mathematics")); students.add(new Student("Carol", "Davis", LocalDate.of(2001, 3, 8), "Physics")); } void displayMenu() { Scanner scanner = new Scanner(System.in); while (true) { System.out.println("\n=== Student Management System ==="); System.out.println("1. List all students"); System.out.println("2. Add new student"); System.out.println("3. Find student by name"); System.out.println("4. Exit"); System.out.print("Choose an option: "); String choice = scanner.nextLine(); switch (choice) { case "1" -> listStudents(); case "2" -> addStudent(scanner); case "3" -> findStudent(scanner); case "4" -> { System.out.println("Goodbye!"); return; } default -> System.out.println("Invalid option!"); } } } void listStudents() { System.out.println("\n=== All Students ==="); for (int i = 0; i < students.size(); i++) { Student student = students.get(i); System.out.printf("%d. %s %s (%s) - %s%n", i + 1, student.firstName(), student.lastName(), student.birthDate(), student.major()); } } void addStudent(Scanner scanner) { System.out.println("\n=== Add New Student ==="); System.out.print("First name: "); String firstName = scanner.nextLine(); System.out.print("Last name: "); String lastName = scanner.nextLine(); System.out.print("Birth date (YYYY-MM-DD): "); LocalDate birthDate = LocalDate.parse(scanner.nextLine()); System.out.print("Major: "); String major = scanner.nextLine(); students.add(new Student(firstName, lastName, birthDate, major)); System.out.println("Student added successfully!"); } void findStudent(Scanner scanner) { System.out.print("Enter name to search: "); String searchName = scanner.nextLine().toLowerCase(); List<Student> found = students.stream() .filter(s -> s.firstName().toLowerCase().contains(searchName) || s.lastName().toLowerCase().contains(searchName)) .toList(); if (found.isEmpty()) { System.out.println("No students found with that name."); } else { System.out.println("\n=== Found Students ==="); found.forEach(s -> System.out.printf("- %s %s (%s)%n", s.firstName(), s.lastName(), s.major())); } } // Record for student data record Student(String firstName, String lastName, LocalDate birthDate, String major) { public int getAge() { return Period.between(birthDate, LocalDate.now()).getYears(); } }

5. Vector API (Seventh Incubator - JEP 460)

The Vector API provides expressive and reliable vector computations that compile to optimal vector hardware instructions.

Basic Vector Operations

```java
import jdk.incubator.vector.*;

public class VectorAPIDemo {

public static void main(String[] args) { var demo = new VectorAPIDemo(); demo.basicVectorOperations(); demo.vectorizedComputation(); demo.performanceComparison(); } public void basicVectorOperations() { // Define vector species (type and size) VectorSpecies<Float> species = FloatVector.SPECIES_PREFERRED; System.out.println("Preferred float vector size: " + species.length()); // Create vectors float[] arrayA = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f}; float[] arrayB = {2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; FloatVector vectorA = FloatVector.fromArray(species, arrayA, 0); FloatVector vectorB = FloatVector.fromArray(species, arrayB, 0); // Vector operations FloatVector sum = vectorA.add(vectorB); FloatVector product = vectorA.mul(vectorB); FloatVector combined = vectorA.fma(vectorB, sum); // Fused multiply-add // Store results float[] result = new float[arrayA.length]; sum.intoArray(result, 0); System.out.println("Vector A: " + vectorA); System.out.println("Vector B: " + vectorB); System.out.println("Sum: " + sum); System.out.println("Product: " + product); System.out.println("FMA: " + combined); } public void vectorizedComputation() { int size = 1024; float[] a = new float[size]; float[] b = new float[size]; float[] c = new float[size]; // Initialize arrays for (int i = 0; i < size; i++) { a[i] = i * 0.1f; b[i] = i * 0.2f; } VectorSpecies<Float> species = FloatVector.SPECIES_PREFERRED; // Vectorized array addition for (int i = 0; i < size; i += species.length()) { VectorMask<Float> mask = species.indexInRange(i, size); FloatVector va = FloatVector.fromArray(species, a, i, mask); FloatVector vb = FloatVector.fromArray(species, b, i, mask); FloatVector vc = va.add(vb); vc.intoArray(c, i, mask); } // Verify results System.out.println("Vectorized computation completed"); System.out.println("Sample result: c[10] = " + c[10]); } public void performanceComparison() { int size = 1000000; float[] array1 = new float[size]; float[] array2 = new float[size]; float[] resultScalar = new float[size]; float[] resultVector = new float[size]; // Initialize arrays with random data for (int i = 0; i < size; i++) { array1[i] = (float) Math.random(); array2[i] = (float) Math.random(); } // Scalar implementation long scalarStart = System.nanoTime(); for (int i = 0; i < size; i++) { resultScalar[i] = array1[i] + array2[i]; } long scalarTime = System.nanoTime() - scalarStart; // Vector implementation long vectorStart = System.nanoTime(); vectorizedAdd(array1, array2, resultVector); long vectorTime = System.nanoTime() - vectorStart; System.out.printf("Scalar time: %,d ns%n", scalarTime