Listing the Available Random Algorithms

System.out.printf("%-13s| %s\n-------------|---------------------\n", "Group", "Name");
java.util.random.RandomGeneratorFactory.all()
        .sorted(java.util.Comparator.comparing(java.util.random.RandomGeneratorFactory::name))
        .forEach(factory -> System.out.printf("%-13s| %s\n", factory.group(), factory.name()));

The output is similar to the following:

Group        | Name
-------------|---------------------
LXM          | L128X1024MixRandom
LXM          | L128X128MixRandom
LXM          | L128X256MixRandom
LXM          | L32X64MixRandom
LXM          | L64X1024MixRandom
LXM          | L64X128MixRandom
LXM          | L64X128StarStarRandom
LXM          | L64X256MixRandom
Legacy       | Random
Legacy       | SecureRandom
Legacy       | SplittableRandom
Xoroshiro    | Xoroshiro128PlusPlus
Xoshiro      | Xoshiro256PlusPlus

Check from the following address on how to choose which algorithm to choose:

https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/random/package-summary.html#algorithms

Creating an instance of RandomGenerator

The default algorithm (i.e. L32X64MixRandom)

var generator = java.util.random.RandomGenerator.getDefault();

The specific algorithm (e.g. L64X128MixRandom)

var generator = java.util.random.RandomGenerator.of("L64X128MixRandom");

Use the static method RandomGenerator.of and pass the name of the algorithm.

Generating Random Number

Use one of the following instance methods of the RandomGenerator class:

• nextDouble()
• nextDouble(double bound)
• nextDouble(double origin, double bound)
• nextFloat()
• nextFloat(float bound)
• nextFloat(float origin, float bound)
• nextInt()
• nextInt(int bound)
• nextInt(int origin, int bound)
• nextLong()
• nextLong(long bound)
• nextLong(long origin, long bound)

The origin parameter is inclusive and bound parameter is exclusive.

Example using a classic random algorithm

 var generator = java.util.random.RandomGenerator.of("Random");
 System.out.println(generator.nextInt());

The output is a random integer number.

Generating Random Number Using Streams

Use one of the following instance methods of RandomGenerators class to create streams:

• doubles()
• doubles(double origin, double bound)
• doubles(long streamSize)
• doubles(long streamSize, double origin, double bound)
• ints()
• ints(int origin, int bound)
• ints(long streamSize)
• ints(long streamSize, int origin, int bound)
• longs()
• longs(long origin, long bound)
• longs(long streamSize)
• longs(long streamSize, long origin, long bound)

The origin parameter is inclusive and bound parameter is exclusive.

Example using a classic random algorithm

var generator = java.util.random.RandomGenerator.of("Random");
var randomInt = generator.ints(100, 1, 100)
        .filter(number -> number % 2 == 0 )
        .findFirst();
randomInt.ifPresent(System.out::println);

The output is a random integer number.

Sealed classes and interfaces restrict which other classes or interfaces may extend or implement them.

public sealed interface IAnimal 
    permits AquaticAnimal, LandAnimal {
    String lifespan();
}

Notice the use of the sealed modifier and permits keyword. The sealed modifier indicates that the class or interface is restricted. The permit keyword indicates which classes (or interfaces) can implement (or extends) it. Thus, the sealed modifier and the permit keyword must be used together.

public sealed abstract class AquaticAnimal implements IAnimal permits SeaTurtle {
}

The class (or interface) that can implement (or extend) a sealed interface (or class) must have one of the following modifiers:

• sealed
• non-sealed
• final

public non-sealed abstract class LandAnimal implements IAnimal {
}

Using the non-sealed modifier indicates that this class can be extended without restriction.

public sealed class Dog extends LandAnimal permits Boxer {
    @Override
    public String lifespan() {
        return "10 - 13 years";
    }
}

Limiting the hierarchy of Dog class to just Boxer class.

public final class Boxer extends Dog {
    @Override
    public String lifespan() {
        return "10 - 12 years";
    }
}

The final implementation of the Dog class.

public class Cat extends LandAnimal {
    @Override
    public String lifespan() {
        return "12 - 18 years";
    }
}

Since LandAnimal is non-sealed abstract class, it can be inherited without restriction.

public final class SeaTurtle extends AquaticAnimal {
    @Override
    public String lifespan() {
        return "Up to 50 years or more";
    }
}

SeaTurtle is the only class that can implement AquaticAnimal. Because this the only class permitted in the AquaticAnimal definition.

The pattern matching enhancement that conditionally extract data from an object if the instanceof operator was satisfied and assigns it to a variable.

The variable in this pattern matching is following a flow scope. This means that the variable is in scope if it is guaranted that it can satisfies the instanceof operator.

Code Without Pattern Matching

record Person(String firstName, String lastName) {}

Record rec = new Person("Juan", "Dela Cruz");

//Check if rec is a Person.
if (rec instanceof Person) {

    //rec can safely be casted to Person.
    var person = (Person) rec;

    System.out.println(person);
    System.out.println(person.firstName());
    System.out.println(person.lastName());
}

Notice that casting the rec to Person once the check succeded is required.

Code With Pattern Matching

record Person(String firstName, String lastName) {}

Record rec = new Person("Juan", "Dela Cruz");

//If rec is a Person extract it to a variable person.
if (rec instanceof Person person) {
    System.out.println(person);
    System.out.println(person.firstName());
    System.out.println(person.lastName());
}

Notice that casting is not required here and Person instance is extracted to person variable. Moreover, the scope of the variable is in the truth block of the if statement.

Flow Scope

Example 1

Record rec = new Person("Juan", "Dela Cruz");

if (!(rec instanceof Person person)) {
    System.out.println("In human.");
}
else {
    System.out.println(person);
    System.out.println(person.firstName());
    System.out.println(person.lastName());
}

Notice that person variable usage is on the else block of the if statement.

Example 2

Record rec = new Person("Juan", "Dela Cruz");

if (rec instanceof Person person && "JUAN DELA CRUZ".equals(String.join(person.firstName(), " ", person.lastName().toUpperCase()))) {
    System.out.println("You won a price");
}

Notice that the person variable is usable after the AND (&&) operator. This is because the and operator guarantees that the instanceof operator was satisfied before evaluating the following condition. Changing it to OR (||) operator will be an error, since the person variable is out of scope.

Practical Usage

equals implementation

import java.util.Objects;

record Person(String firstName, String lastName) {

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (null == o) return false;
        if (o instanceof Person person) {
            return Objects.equals(firstName, person.firstName()) && Objects.equals(lastName, person.lastName());
        }
        return false;
    }

}