Java 10 New Features

Java 10 introduced numerous new features, among which the most significant include:

1. Local Variable Type Inference: Java 10 allows type inference in local variable declarations, making code more concise and readable. Developers can declare variables using the var keyword without explicitly specifying their types.
2. G1 Garbage Collector Parallel Full Phase: Java 10 improved the G1 garbage collector to perform memory reclamation operations during parallel phases, thereby enhancing application performance and responsiveness.
3. Application Class Data Sharing (ACDS): Java 10 introduced Application Class Data Sharing functionality, which helps developers launch Java applications more efficiently. ACDS enables sharing of class data across multiple Java processes, reducing both memory usage and startup time.
4. Thread-Local Handshakes: A new Thread-Local Handshake mechanism was introduced in Java 10. It allows threads to be stopped during garbage collection while performing specific operations, thus improving application performance and responsiveness.
5. Enhanced Optional Class: Several new methods and features were added to the Optional class in Java 10, making it easier to use and understand. These improvements include methods such as orElseThrow() and ifPresentOrElse().

// Example demonstrating local variable type inference with var keyword
public void exampleMethod() {
    // Type is inferred from assignment expression
    var list = new ArrayList<String>();
    
    // Another example using lambda expressions where return types are often omitted or inferred
    List<Integer> numbers = Arrays.stream(1, 2, 3).boxed().collect(Collectors.toList());

    if (numbers.isEmpty()) {
        System.out.println("List is empty");
    } else {
        var sum = numbers.stream()
                        .mapToInt(Integer::intValue)
                        .sum();
        System.out.println("Sum: " + sum); // Output depends on input data
    }

    Optional<String> optionalValue = getOptionalData();
    
    if (optionalValue.isPresent()) {
        var value = optionalValue.get();
        process(value);
    } else {
        handleMissingValue();
    }
}

// Helper method to simulate fetching an optional data source
private Optional<String> getOptionalData() {
    // Simulate a scenario where data might be null or absent
    return Arrays.asList("data1", "data2").stream()
           .filter(item -> item != null)
           .findFirst();
}

// Placeholder for processing logic when optional value is present
private void process(String val) {
    System.out.println("Processing: " + val);
}

// Logic to handle cases where the optional value is missing
private void handleMissingValue() {
    System.out.println("No data available");
}