Java 16: Records and Vector API

// Standard feature - no preview needed!
public record Employee(long id, String name, String department, double salary) {
    
    // Compact constructor for validation
    public Employee {
        if (salary < 0) {
            throw new IllegalArgumentException("Salary cannot be negative");
        }
        name = name.trim();
    }
    
    // Methods can be added
    public boolean isSalariedAbove(double threshold) {
        return salary > threshold;
    }
    
    // Static members allowed
    public static Employee dummy() {
        return new Employee(0, "Unknown", "N/A", 0);
    }
}
 
// Usage is clean and intuitive
Employee emp = new Employee(1, "Alice", "Engineering", 95000);
System.out.println(emp.name());      // Direct field access
System.out.println(emp.isSalariedAbove(90000)); // true
System.out.println(emp);             // toString() auto-generated
 
// Equals and hashCode work perfectly
Employee emp2 = new Employee(1, "Alice", "Engineering", 95000);
System.out.println(emp.equals(emp2)); // true - perfect for collections
 
// Destructuring (future enhancement)
// var (id, name, dept, salary) = emp; // Coming in future Java versions

// Vector operations for parallel computation
import jdk.incubator.vector.*;
 
public class VectorExample {
    static final VectorSpecies<Integer> SPECIES = IntVector.SPECIES_PREFERRED;
    
    // Traditional loop - processes one element at a time
    public static void addScalarLoop(int[] a, int[] b, int[] result) {
        for (int i = 0; i < a.length; i++) {
            result[i] = a[i] + b[i]; // Sequential
        }
    }
    
    // Vector operation - processes multiple elements in parallel
    public static void addVector(int[] a, int[] b, int[] result) {
        int i = 0;
        // Process chunks using SIMD
        for (; i < SPECIES.loopBound(a.length); i += SPECIES.length()) {
            IntVector va = IntVector.fromArray(SPECIES, a, i);
            IntVector vb = IntVector.fromArray(SPECIES, b, i);
            IntVector sum = va.add(vb);
            sum.intoArray(result, i);
        }
        // Handle remainder
        for (; i < a.length; i++) {
            result[i] = a[i] + b[i];
        }
    }
    
    // Benefits: 10-100x faster for large datasets!
    public static void benchmark() {
        int[] a = new int[10000];
        int[] b = new int[10000];
        int[] result = new int[10000];
        
        long start = System.nanoTime();
        addVector(a, b, result);
        long duration = System.nanoTime() - start;
        System.out.println("Vector operation: " + duration + " ns");
    }
}

// Standard feature - not preview
public void processObject(Object obj) {
    // Clean pattern matching
    if (obj instanceof String str) {
        System.out.println("String length: " + str.length());
    } else if (obj instanceof Integer num) {
        System.out.println("Integer value: " + num);
    } else if (obj instanceof Employee emp) {
        System.out.println("Employee: " + emp.name());
    }
}
 
// Pattern matching with logical operators
public boolean validateInput(Object input) {
    return input instanceof String str &&
           str.length() > 0 &&
           !str.isBlank();
}
 
// Nested patterns (coming in future versions)
public void analyzeData(Object data) {
    if (data instanceof Employee emp &&
        emp.isSalariedAbove(100000)) {
        System.out.println("High earner: " + emp.name());
    }
}

// Sealed classes work perfectly with records
public sealed interface Shape permits Circle, Square, Rectangle {}
 
public record Circle(double radius) implements Shape {}
public record Square(double side) implements Shape {}
public record Rectangle(double width, double height) implements Shape {}
 
// Exhaustive pattern matching
public double calculateArea(Shape shape) {
    return switch (shape) {
        case Circle(double r) -> Math.PI * r * r;
        case Square(double s) -> s * s;
        case Rectangle(double w, double h) -> w * h;
    };
}
 
// Sealed classes enforce domain constraints
public sealed class PaymentMethod permits CreditCard, PayPal {}
public final class CreditCard extends PaymentMethod {}
public final class PayPal extends PaymentMethod {}

// mapMulti: Replace elements with multiple values efficiently
List<Integer> numbers = Arrays.asList(1, 2, 3);
numbers.stream()
    .mapMulti((n, consumer) -> {
        consumer.accept(n);
        consumer.accept(n * 10);
    })
    .forEach(System.out::println);
// Output: 1, 10, 2, 20, 3, 30
 
// Practical example
public Stream<String> allWords(Stream<String> lines) {
    return lines.mapMulti((line, consumer) -> {
        for (String word : line.split("\\s+")) {
            if (!word.isEmpty()) {
                consumer.accept(word);
            }
        }
    });
}

import sun.misc.Unsafe;
 
// ❌ This and other internal APIs are now inaccessible
// Throws: java.lang.reflect.InaccessibleObjectException
// Need to use: --add-opens java.base/sun.misc=ALL-UNNAMED
 
// Recommended: Use public APIs instead
// sun.misc.Unsafe -> java.util.concurrent, VarHandle, etc.

// Vector API for financial calculations
public double[] vectorizedMovingAverage(double[] prices, int window) {
    double[] result = new double[prices.length - window + 1];
    
    for (int i = 0; i < result.length; i++) {
        double sum = 0;
        // Replace with vector operations for better performance
        for (int j = 0; j < window; j++) {
            sum += prices[i + j];
        }
        result[i] = sum / window;
    }
    
    return result;
}
 
// With records for clean data
record PriceData(double[] prices, LocalDate date) {}
record MovingAverage(double[] values, int window) {}

// Modern Java 16 application structure
public sealed interface DataSource permits DatabaseSource, APISource, FileSource {}
 
public record DatabaseSource(String connection) implements DataSource {}
public record APISource(String endpoint) implements DataSource {}
public record FileSource(Path filePath) implements DataSource {}
 
// Type-safe data loading
public String loadData(DataSource source) {
    if (source instanceof DatabaseSource db) {
        return queryDatabase(db.connection());
    } else if (source instanceof APISource api) {
        return fetchFromAPI(api.endpoint());
    } else if (source instanceof FileSource file) {
        return readFile(file.filePath());
    }
    return "";
}