We will start this new year with an episode dedicated to optionals in Java.

What are optionals? Well, we can think of them as the Java way of expressing something that can be there, but that can also not be there: an optional indeed!

Suppose you have a method which calculates the average number of points a basketball player made during a season. It will probably look something like this:

``````
public double getAverage(List<Integer> pointsList) {
double average = 0.;
if(pointList.isEmpty()) {
return average;
}
for(Integer point : pointsList) {
average += point;
}
return average /= pointsList.size();
}

``````

where, every entry of `pointsList` is the total number of points made by a player on each match of the season.

So, let’s suppose we call such a method before the beginning of the season. In this case our `pointsList` is empty, and, as we built the method, we would get `0.0` as result. But this is the same result you would have gotten for a player who scored no point when the season is over, right? So, it seems a bit unfair with respect to the previous player, which has not scored any point just because he has not played yet!

We can modify this method to return, instead of a `double`, an `Optional<Double>`:

``````
public Optional<Double> getAverage(List<Integer> pointsList) {
double average = 0.;
if(pointList.isEmpty()) {
return Optional.empty();
}
for(Integer point : pointsList) {
average += point;
}
return Optional.of(average /= pointsList.size());
}

``````

As you can see, in this way, if there are no values in the input list we return an empty `Optional`, which corresponds to the case in which we cannot actually make an average since we do not have any point. While, in case the list is not empty, but the corresponding values are all zeros, we would get an `Optional` containing the actual value of zero, since an average in this case was possible.

You have probably noticed that we created the `Optional` not through a constructor, but using a factory, namely using a `static` method of the `Optional` class, which internally calls the constructor for us. This is a common pattern in Java.

In particular, in our case, `Optional.empty()` creates an empty `Optional`, while `Optional.of()` creates an `Optional` with the given value.

Once you get the resulting `Optional` from our method, how can you determine whether there is actually a value associated with the `Optional` or not? You can do that in different ways.

``````
Optional<Double> average = getAverage(new ArrayList<Integer>());
Double v1;
//WAY 1
if(average.isPresent()) {
v1 = average.get();
}

//WAY 2
v1 = average.orElse(null);

//WAY 3
v1 = average.orElseGet(()->null);

//WAY 4
v1 = average.orElseThrow();

``````

Let’s look over the different examples.

The first one is maybe the simplest one: it simply checks whether a value is present in the `Optional` and, if so, it gets it. It requires two actions from our side, though.

The second method takes care by itself of the fact that the `Optional` can be empty, and if so, it returns the value we specify as parameter, which in our case is `null`.

A slight variant of this method is the `orElseGet()`, which, instead of taking directly an alternative value, it takes a `Supplier` of the type of the `Optional`, so, in our case `Double`. In our third example, we used this method to set the value of `v1` to `null`, in case nothing is present in the `Optional`.

The fourth described way allows you to throw an `Exception` whether the `Optional` is empty. The thrown exception is a `NoSuchElementException`. However, you can provide your own `Exception` using the overloaded version of such a method, which takes as parameter a `Supplier` of type `Throwable`.

That’s it for today! Now you know what are `Optional` in Java and how to use them!

Stay tuned for the next episode of the series!