Java 9 In-Depth Features

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

1. Modular System: Java 9 introduced a modular system that provides a better way to manage and organize code. The modular system helps developers more easily manage project dependencies and version control.
2. JShell: JShell is a new interactive programming tool that helps developers test and debug code more easily. JShell allows developers to input code into the command-line interface and see results immediately.
3. Collection Factory Methods: Java 9 introduced several new collection factory methods, making it simpler and more direct to create collections. These methods help developers reduce code volume and improve code readability and maintainability.
4. Private Methods in Interfaces: Java 9 allows the definition of private methods within interfaces, which can only be used internally within the interface itself. This feature helps developers implement interfaces more flexibly and improves code readability and maintainability.
5. Enhanced Stream API: Java 9 enhanced the Stream API by adding new methods and features, making it easier for developers to process stream data.
6. Improved Garbage Collector: Java 9 introduced a new garbage collector that can handle large memory and long-running applications more effectively.

// Example demonstrating JShell usage conceptually
// In actual JShell sessions, you would type commands directly in the terminal
public class Main {
    public static void main(String[] args) {
        // This code would be entered interactively in JShell for immediate feedback
        System.out.println("Hello from Java 9!");
    }
}

// Example demonstrating Collection Factory Methods
import java.util.*;

public class CollectionsExample {
    public static void main(String[] args) {
        // Using factory methods to create collections directly
        List<String> list = List.of("a", "b", "c");
        Set<Integer> set = Set.of(1, 2, 3);
        
        System.out.println(list);
        System.out.println(set);
    }
}

// Example demonstrating Private Methods in Interfaces
import java.util.function.*;

public class InterfacePrivateMethods {
    public interface Processor {
        void process();
        
        // Private method defined within the interface
        private void helper() {
            System.out.println("Executing helper logic");
        }
        
        @Override
        default void process() {
            helper();
            System.out.println("Processing complete");
        }
    }
    
    public static void main(String[] args) {
        Processor p = new Processor() {};
        p.process(); // Calls the default implementation which uses the private helper
    }
}

// Example demonstrating Stream API enhancements
import java.util.*;
import java.util.stream.*;

public class StreamEnhancements {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        
        // Using new stream operations available in Java 9
        List<Integer> evens = numbers.stream()
                                    .filter(n -> n % 2 == 0)
                                    .collect(Collectors.toList());
        
        System.out.println(evens);
    }
}

// Example demonstrating Garbage Collector improvements
import java.lang.management.*;

public class GCImprovements {
    public static void main(String[] args) {
        // Simulating long-running application with large memory usage
        int[] largeArray = new int[10_000_000];
        
        // Monitoring garbage collection in production environments would use:
        MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
        ObjectName gcName = new ObjectName("java.lang:type=GC");
        
        System.out.println("Large array allocated for memory testing");
        System.gc(); // Manual trigger (not recommended for production)
    }
}