Devops Monk

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

static void fillWithRandom(int[] array, RandomGenerator rng) {
    for (int i = 0; i < array.length; i++) {
        array[i] = rng.nextInt();
    }
}

// Works with any generator
fillWithRandom(arr, new java.util.Random());
fillWithRandom(arr, RandomGeneratorFactory.of("L64X128MixRandom").create());
fillWithRandom(arr, java.util.concurrent.ThreadLocalRandom.current());

RandomGenerator rng = RandomGeneratorFactory.getDefault().create();

rng.nextInt()           // random int (full range)
rng.nextInt(100)        // random int in [0, 100)
rng.nextInt(10, 50)     // random int in [10, 50)
rng.nextLong()          // random long
rng.nextDouble()        // random double in [0.0, 1.0)
rng.nextDouble(1.5)     // random double in [0.0, 1.5)
rng.nextDouble(0.5, 2.0) // random double in [0.5, 2.0)
rng.nextBoolean()       // random boolean
rng.nextFloat()         // random float in [0.0, 1.0)
rng.nextGaussian()      // normally distributed (mean=0, std=1)
rng.nextGaussian(5.0, 2.0) // normally distributed (mean=5, std=2)
rng.nextExponential()   // exponentially distributed (lambda=1)

// Streams
rng.ints(100)           // IntStream of 100 random ints
rng.longs(50)           // LongStream of 50 random longs
rng.doubles(200)        // DoubleStream of 200 random doubles
rng.ints(100, 0, 10)   // 100 random ints in [0, 10)

import java.util.random.RandomGeneratorFactory;

// List all available algorithms
RandomGeneratorFactory.all()
    .forEach(f -> System.out.printf("%-30s period=%d stateBits=%d%n",
        f.name(), f.period(), f.stateBits()));

// Instantiate a specific algorithm
RandomGenerator rng = RandomGeneratorFactory.of("L64X128MixRandom").create();

// With a seed (for reproducibility)
RandomGenerator seeded = RandomGeneratorFactory.of("L64X128MixRandom").create(42L);

// Default algorithm
RandomGenerator defaultRng = RandomGeneratorFactory.getDefault().create();

import java.util.random.RandomGenerator.JumpableGenerator;

JumpableGenerator rng = (JumpableGenerator) RandomGeneratorFactory
    .of("L64X128MixRandom").create(42L);

// Jump creates a new generator positioned 2^64 steps ahead
// The original rng continues from its current position
JumpableGenerator jumped = rng.jump();

// Each jump produces an independent, non-overlapping sequence
// Use this for parallel workloads: give each thread its own jumped generator

static int[] parallelFill(int size, long seed) {
    JumpableGenerator master = (JumpableGenerator) RandomGeneratorFactory
        .of("L64X128MixRandom").create(seed);

    int[] result = new int[size];
    int nThreads = Runtime.getRuntime().availableProcessors();
    int chunkSize = size / nThreads;

    // Create independent generators for each thread
    JumpableGenerator[] rngs = new JumpableGenerator[nThreads];
    rngs[0] = master;
    for (int i = 1; i < nThreads; i++) {
        rngs[i] = rngs[i - 1].jump(); // each jumps past the previous
    }

    IntStream.range(0, nThreads).parallel().forEach(t -> {
        int start = t * chunkSize;
        int end = (t == nThreads - 1) ? size : start + chunkSize;
        for (int i = start; i < end; i++) {
            result[i] = rngs[t].nextInt();
        }
    });
    return result;
}

import java.util.random.RandomGenerator.SplittableGenerator;

SplittableGenerator parent = (SplittableGenerator) RandomGeneratorFactory
    .of("L64X128MixRandom").create();

// Split creates a new independent generator
SplittableGenerator child = parent.split();

SplittableGenerator rng = new java.util.SplittableRandom();
SplittableGenerator copy = rng.split();

// Recursive parallel computation with independent RNGs
long computeInParallel(SplittableGenerator rng, int depth) {
    if (depth == 0) return rng.nextLong();
    SplittableGenerator left  = rng.split();
    SplittableGenerator right = rng.split();
    return computeInParallel(left, depth - 1) + computeInParallel(right, depth - 1);
}

import java.util.random.RandomGenerator.StreamableGenerator;

StreamableGenerator rng = (StreamableGenerator) RandomGeneratorFactory
    .of("L64X128MixRandom").create();

// Stream of 8 independent generators
rng.rngs(8)
   .parallel()
   .mapToDouble(r -> r.nextDouble())
   .sum();

RandomGenerator rng1 = RandomGeneratorFactory.of("L64X128MixRandom").create(12345L);
RandomGenerator rng2 = RandomGeneratorFactory.of("L64X128MixRandom").create(12345L);

// Same seed → same sequence
rng1.nextInt() == rng2.nextInt(); // true
rng1.nextInt() == rng2.nextInt(); // true

RandomGeneratorFactory.all()
    .filter(f -> f.isJumpable())
    .filter(f -> f.stateBits() >= 128)
    .sorted(Comparator.comparingInt(RandomGeneratorFactory::stateBits))
    .forEach(f -> System.out.printf("%-30s period=%s bits=%d%n",
        f.name(), f.period(), f.stateBits()));