**Get started with Spring 5 and Spring Boot 2, through the ***Learn Spring* course:

*Learn Spring*course:

Last modified: June 27, 2022

In this tutorial, we'll look at a few examples of how we can implement probability with Java.

**To simulate probability in Java, the first thing we need to do is to generate random numbers.** Fortunately, Java provides us with plenty of *random numbers generators*.

In this case, we'll use the *SplittableRandom* class because it provides high-quality randomness and is relatively fast:

`SplittableRandom random = new SplittableRandom();`

Then we need to generate a number in a range and compare it to another number chosen from that range. Every number in the range has an equal chance of being drawn. As we know the range, we know the probability of drawing our chosen number. **That way we're controlling probability**:

`boolean probablyFalse = random.nextInt(10) == 0`

In this example, we drew numbers from 0 to 9. Therefore, the probability of drawing 0 is equal to 10%. Now, let's get a random number and test if the chosen number is lower than the drawn one:

`boolean whoKnows = random.nextInt(1, 101) <= 50`

Here, we drew numbers from 1 to 100. The chance for our random number to be lesser or equal to 50 is exactly 50%.

Values generated up to this point fall into the uniform distribution. This means that **every event, for example rolling some number on a dice, has an equal chance of happening.**

Now, let's say we want to perform a task from time to time and control its probability. For example, we operate an e-commerce site and we want to give a discount to 10% of our users.

To do so, let's implement a method that will take three parameters: a supplier to invoke in some percentage of cases, a second supplier to invoke in the rest of the cases, and the probability.

First, we declare our *SplittableRandom* as *Lazy *using Vavr. This way we'll instantiate it only once, on a first request:

```
private final Lazy<SplittableRandom> random = Lazy.of(SplittableRandom::new);
```

Then, we'll implement the probability-managing function:

```
public <T> withProbability(Supplier<T> positiveCase, Supplier<T> negativeCase, int probability) {
SplittableRandom random = this.random.get();
if (random.nextInt(1, 101) <= probability) {
return positiveCase.get();
} else {
return negativeCase.get();
}
}
```

Let's reverse the process we saw in the previous section. To do so, we'll measure the probability using the Monte Carlo method. It generates a high volume of random events and counts how many of them satisfy the provided condition. **It's useful when the probability is hard or impossible to compute analytically.**

For example, if we look at six-sided dice we know that the probability of rolling a certain number is 1/6. But, if we have a mysterious dice with an unknown number of sides, it'd be hard to tell what the probability would be. **Instead of analyzing the dice we could just roll it numerous times and count how many times certain events are occurring.**

Let's see how we can implement this approach. First, we'll try to generate the number 1 with the probability of 10% for a million times and count them:

```
int numberOfSamples = 1_000_000;
int probability = 10;
int howManyTimesInvoked =
Stream.generate(() -> randomInvoker.withProbability(() -> 1, () -> 0, probability))
.limit(numberOfSamples)
.mapToInt(e -> e)
.sum();
```

Then, the sum of generated numbers divided by the number of samples will be an approximation of the probability of the event:

```
int monteCarloProbability = (howManyTimesInvoked * 100) / numberOfSamples;
```

Mind that, the computed probability is approximated. The higher the number of samples, the better the approximation will be.

The uniform distribution works well for modeling things like games. For the game to be fair, all the events often need to have the same probability of happening.

However, in real life, distributions are usually more complicated. The chances are not equal for different things to happen.

For example, there are very few extremely short people and very few extremely tall. Most people are of average height, which means that the height of people follows the normal distribution. If we need to generate random human heights, then it won't suffice to generate a random number of feet.

Fortunately, we don't need to implement the underlying mathematical model ourselves. **We need to know which distribution to use and how to configure it**, for example, using statistical data.

The Apache Commons library provides us with implementations for several distributions. Let's implement the normal distribution with it:

```
private static final double MEAN_HEIGHT = 176.02;
private static final double STANDARD_DEVIATION = 7.11;
private static NormalDistribution distribution = new NormalDistribution(MEAN_HEIGHT, STANDARD_DEVIATION);
```

Using this API is very straightforward – the sample method draws a random number from the distribution:

```
public static double generateNormalHeight() {
return distribution.sample();
}
```

Finally, let's invert the process:

```
public static double probabilityOfHeightBetween(double heightLowerExclusive, double heightUpperInclusive) {
return distribution.probability(heightLowerExclusive, heightUpperInclusive);
}
```

As a result, we'll get the probability of a person having a height between two bounds. In this case, the lower and the upper heights.

In this article, we learned how to generate random events and how to compute the probability of them happening. We used uniform and normal distributions to model different situations.

The full example can be found over on GitHub.

Follow the Java Category

Follow the Java category to get regular info about the new articles and tutorials we publish here.