Java 17 Other Improvements

// This code throws NPE -- but which reference is null?
String city = user.getAddress().getCity().toUpperCase();

// Java 11 error message:
// Exception in thread "main" java.lang.NullPointerException
//     at com.example.App.main(App.java:15)
//
// Which one is null? user? getAddress()? getCity()?
// You have to add breakpoints or null checks to find out.

// Same code on Java 17:
String city = user.getAddress().getCity().toUpperCase();

// Java 17 error message:
// Exception in thread "main" java.lang.NullPointerException:
//     Cannot invoke "Address.getCity()" because the return value of
//     "User.getAddress()" is null
//     at com.example.App.main(App.java:15)
//
// Instantly tells you: getAddress() returned null

// Array access
int[] arr = null;
int x = arr[0];
// Cannot load from int array because "arr" is null

// Field access
String name = person.name;
// Cannot read field "name" because "person" is null

// Method invocation
String upper = str.toUpperCase();
// Cannot invoke "String.toUpperCase()" because "str" is null

// Array store
Object[] objs = null;
objs[0] = "hello";
// Cannot store to object array because "objs" is null

// Nested chains
int length = order.getCustomer().getProfile().getBio().length();
// Cannot invoke "String.length()" because the return value of
// "Profile.getBio()" is null

List names = List.of("Alice", "Bob", "Charlie", "Diana");

// Before Java 16 -- verbose
List filtered = names.stream()
    .filter(n -> n.length() > 3)
    .collect(Collectors.toList());

// Java 16+ -- concise
List filtered = names.stream()
    .filter(n -> n.length() > 3)
    .toList();

List names = List.of("Alice", "Bob", "Charlie");

// Collectors.toList() -- mutable (returns ArrayList)
List mutable = names.stream()
    .filter(n -> n.length() > 3)
    .collect(Collectors.toList());
mutable.add("Eve");         // works fine
mutable.sort(null);         // works fine
mutable.set(0, "Updated");  // works fine

// Stream.toList() -- UNMODIFIABLE
List immutable = names.stream()
    .filter(n -> n.length() > 3)
    .toList();
immutable.add("Eve");         // throws UnsupportedOperationException
immutable.sort(null);         // throws UnsupportedOperationException
immutable.set(0, "Updated");  // throws UnsupportedOperationException

// Stream.toList() ALLOWS null elements
List withNulls = Stream.of("a", null, "b").toList();
// [a, null, b] -- works fine

// List.of() does NOT allow nulls
List fails = List.of("a", null, "b");
// throws NullPointerException

// Collectors.toList() also allows nulls
List alsoWorks = Stream.of("a", null, "b")
    .collect(Collectors.toList());
// [a, null, b] -- works fine

import java.util.random.RandomGenerator;
import java.util.random.RandomGeneratorFactory;

// Create a random generator using the default algorithm
RandomGenerator generator = RandomGenerator.getDefault();

// Generate different types
int randomInt = generator.nextInt(100);           // 0-99
long randomLong = generator.nextLong();
double randomDouble = generator.nextDouble();     // 0.0 to 1.0
boolean randomBool = generator.nextBoolean();
double gaussian = generator.nextGaussian();       // normal distribution

// Bounded ranges
int between10And50 = generator.nextInt(10, 50);   // 10 to 49
double between1And10 = generator.nextDouble(1.0, 10.0);

// List all available algorithms
RandomGeneratorFactory.all()
    .sorted(Comparator.comparing(RandomGeneratorFactory::name))
    .forEach(factory -> System.out.printf("%-20s | Group: %-15s | Period: 2^%d%n",
        factory.name(), factory.group(),
        (int) Math.log(factory.period().doubleValue()) / (int) Math.log(2)));

// Choose a specific algorithm
RandomGenerator xoshiro = RandomGeneratorFactory.of("Xoshiro256PlusPlus").create();
RandomGenerator l128x256 = RandomGeneratorFactory.of("L128X256MixRandom").create();

// Create with a seed for reproducibility
RandomGenerator seeded = RandomGeneratorFactory.of("Xoshiro256PlusPlus").create(42L);

// Common algorithms available in Java 17:
// - L32X64MixRandom    (good general purpose)
// - L64X128MixRandom   (better period)
// - L128X256MixRandom  (very large period)
// - Xoshiro256PlusPlus (fast, good quality)
// - Xoroshiro128PlusPlus (fast, smaller state)

import java.util.random.RandomGenerator.SplittableGenerator;

// Create a splittable generator
SplittableGenerator splittable =
    (SplittableGenerator) RandomGeneratorFactory.of("L64X128MixRandom").create();

// Generate random numbers in parallel safely
List randomNumbers = splittable.splits(10) // 10 independent generators
    .parallel()
    .mapToInt(gen -> gen.nextInt(1000))
    .boxed()
    .toList();

// Monte Carlo simulation example
SplittableGenerator rng =
    (SplittableGenerator) RandomGeneratorFactory.of("L128X256MixRandom").create(42L);

long totalPoints = 10_000_000L;
long insideCircle = rng.splits(totalPoints)
    .parallel()
    .filter(gen -> {
        double x = gen.nextDouble();
        double y = gen.nextDouble();
        return x * x + y * y <= 1.0;
    })
    .count();

double piEstimate = 4.0 * insideCircle / totalPoints;
System.out.printf("Pi estimate: %.6f%n", piEstimate);

import java.text.NumberFormat;
import java.util.Locale;

// Short format (default)
NumberFormat shortFormat = NumberFormat.getCompactNumberInstance(
    Locale.US, NumberFormat.Style.SHORT);

System.out.println(shortFormat.format(1_000));         // "1K"
System.out.println(shortFormat.format(1_500));         // "2K" (rounds)
System.out.println(shortFormat.format(1_000_000));     // "1M"
System.out.println(shortFormat.format(1_500_000));     // "2M"
System.out.println(shortFormat.format(1_000_000_000)); // "1B"
System.out.println(shortFormat.format(42));            // "42"

// Long format -- spells out the suffix
NumberFormat longFormat = NumberFormat.getCompactNumberInstance(
    Locale.US, NumberFormat.Style.LONG);

System.out.println(longFormat.format(1_000));         // "1 thousand"
System.out.println(longFormat.format(1_000_000));     // "1 million"
System.out.println(longFormat.format(1_000_000_000)); // "1 billion"

// Control decimal places
shortFormat.setMaximumFractionDigits(1);
System.out.println(shortFormat.format(1_500));         // "1.5K"
System.out.println(shortFormat.format(1_230_000));     // "1.2M"

// Different locales
NumberFormat germanShort = NumberFormat.getCompactNumberInstance(
    Locale.GERMANY, NumberFormat.Style.SHORT);
System.out.println(germanShort.format(1_000_000)); // "1 Mio."

NumberFormat japaneseShort = NumberFormat.getCompactNumberInstance(
    Locale.JAPAN, NumberFormat.Style.SHORT);
System.out.println(japaneseShort.format(10_000)); // "1万"

import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.Locale;

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("h:mm B", Locale.US);

System.out.println(LocalTime.of(8, 30).format(formatter));   // "8:30 in the morning"
System.out.println(LocalTime.of(12, 0).format(formatter));   // "12:00 noon"
System.out.println(LocalTime.of(14, 30).format(formatter));  // "2:30 in the afternoon"
System.out.println(LocalTime.of(18, 45).format(formatter));  // "6:45 in the evening"
System.out.println(LocalTime.of(22, 0).format(formatter));   // "10:00 at night"
System.out.println(LocalTime.of(0, 0).format(formatter));    // "12:00 midnight"

// Compare with AM/PM
DateTimeFormatter amPm = DateTimeFormatter.ofPattern("h:mm a", Locale.US);
System.out.println(LocalTime.of(14, 30).format(amPm));       // "2:30 PM"
// vs
System.out.println(LocalTime.of(14, 30).format(formatter));  // "2:30 in the afternoon"

// Works with different locales
DateTimeFormatter germanFormatter = DateTimeFormatter.ofPattern("H:mm B", Locale.GERMANY);
System.out.println(LocalTime.of(14, 30).format(germanFormatter)); // "14:30 nachmittags"

// Note: This requires --add-modules jdk.incubator.foreign
// and is an incubator API in Java 17. Syntax may change.

import jdk.incubator.foreign.*;
import java.lang.invoke.MethodHandle;

// Call strlen from the C standard library -- no JNI code needed
public class PanamaExample {

    public static void main(String[] args) throws Throwable {
        // Get a linker for the platform's C ABI
        CLinker linker = CLinker.systemCLinker();

        // Look up the strlen function
        MethodHandle strlen = linker.downcallHandle(
            CLinker.systemLookup().lookup("strlen").get(),
            FunctionDescriptor.of(ValueLayout.JAVA_LONG, ValueLayout.ADDRESS)
        );

        // Allocate native memory for a C string
        try (ResourceScope scope = ResourceScope.newConfinedScope()) {
            MemorySegment cString = CLinker.toCString("Hello, Panama!", scope);
            long length = (long) strlen.invoke(cString);
            System.out.println("String length: " + length); // 14
        }
        // Native memory is automatically freed when scope closes
    }
}

// Note: Requires --add-modules jdk.incubator.vector
// This is an incubator API in Java 17

import jdk.incubator.vector.*;

public class VectorExample {

    // Traditional scalar addition -- processes one element at a time
    public static float[] scalarAdd(float[] a, float[] b) {
        float[] result = new float[a.length];
        for (int i = 0; i < a.length; i++) {
            result[i] = a[i] + b[i];
        }
        return result;
    }

    // Vector API -- processes multiple elements per instruction
    static final VectorSpecies SPECIES = FloatVector.SPECIES_PREFERRED;

    public static float[] vectorAdd(float[] a, float[] b) {
        float[] result = new float[a.length];
        int i = 0;
        int upperBound = SPECIES.loopBound(a.length);

        // Process chunks using SIMD
        for (; i < upperBound; i += SPECIES.length()) {
            FloatVector va = FloatVector.fromArray(SPECIES, a, i);
            FloatVector vb = FloatVector.fromArray(SPECIES, b, i);
            FloatVector vr = va.add(vb);
            vr.intoArray(result, i);
        }

        // Handle remaining elements
        for (; i < a.length; i++) {
            result[i] = a[i] + b[i];
        }
        return result;
    }
}

// This code worked in Java 8-15 but FAILS in Java 17:
import sun.misc.Unsafe;

// Accessing internal class -- blocked
Field f = Unsafe.class.getDeclaredField("theUnsafe");
f.setAccessible(true); // throws InaccessibleObjectException in Java 17
Unsafe unsafe = (Unsafe) f.get(null);

// Reflective access to java.base internals -- also blocked
var field = String.class.getDeclaredField("value");
field.setAccessible(true); // throws InaccessibleObjectException

// Instead of sun.misc.BASE64Encoder (removed)
import java.util.Base64;
String encoded = Base64.getEncoder().encodeToString(data);

// Instead of sun.misc.Unsafe for memory operations
// Use VarHandle (Java 9+)
import java.lang.invoke.VarHandle;
import java.lang.invoke.MethodHandles;

// Instead of com.sun.org.apache.xerces for XML
// Use javax.xml.parsers (public API)

// JVM flags to open internal modules
// --add-opens java.base/java.lang=ALL-UNNAMED
// --add-opens java.base/java.util=ALL-UNNAMED
// --add-opens java.base/sun.nio.ch=ALL-UNNAMED

// In Maven, add to maven-surefire-plugin configuration:
// --add-opens java.base/java.lang=ALL-UNNAMED

// Deprecated -- do not use in new code
System.setSecurityManager(new SecurityManager()); // produces deprecation warning

// The SecurityManager will be removed in a future Java version.
// Migration strategy:
// - Use containerization (Docker) for isolation
// - Use OS-level permissions
// - Use Java module system for encapsulation
// - Use custom ClassLoaders for restricted code execution

---