Больше нет оправданий использованию пустых ссылок в Java 8

К сожалению, подавляющее большинство языков, созданных в последние десятилетия, были построены с одним и тем же неправильным дизайнерским решением, поэтому разработчики языков и разработчики программного обеспечения начали искать обходные пути, чтобы избежать печально известного исключения NullPointerException.

Функциональные языки, такие как Haskell или Scala, структурно решают эту проблему, заключая обнуляемые значения в монаду Option / Maybe. Другие императивные языки, такие как Groovy, ввели 
безопасный для разыменования оператор разыменования  (? Оператор) для безопасной навигации по значениям, которые могут быть потенциально нулевыми. 
подобная функция  была предложена (а затем отвергнута) как часть проекта Coin в Java 7.

Честно говоря, я не пропускаю нулевой безопасный оператор разыменования в Java, даже потому что могу представить, что большинство разработчиков начнут злоупотреблять им «просто в кейс». Более того, поскольку в следующей версии Java 8 будут лямбда-выражения, будет просто реализовать монаду Option, которая, как я надеюсь показать в оставшейся части статьи, является гораздо более мощной и гибкой конструкцией. 

Я не хочу углубляться в теорию категорий и объяснять, что такое монада, даже потому что уже есть тонны 
очень хороших
статей,
делающих это, Моя цель — быстро реализовать монаду Option с использованием синтаксиса лямбда-выражений Java 8, а затем показать, как ее использовать, на очень практичном примере. В Scala монада M — это любой класс, имеющий следующие 3 метода:

public interface Predicate<T> {
    boolean test(T t);
}

public interface Func1<A1, R> {
    R apply(A1 arg1);
} 

В абстрактном классе Option есть две конкретные реализации, одна из которых представляет отсутствие значения (то, что мы используем для ошибочного моделирования с помощью печально известная нулевая ссылка):

public class None<A> extends Option<A> {

    None() { }

    @Override
    public <B> Option<B> map(Func1<A, B> f) {
        return NONE;
    }

    @Override
    public <B> Option<B> flatMap(Func1<A, Option<B>> f) {
        return NONE;
    }

    @Override
    public Option<A> filter(Predicate<? super A> predicate) {
        return NONE;
    }

    @Override
    public A getOrElse(A def) {
        return def;
    }
}

int readPositiveIntParam(Map<String, String> params, String name) { // TODO ... }

@Test
public void testMap() {
    Map<String, String> param = new HashMap<String, String>();
    param.put("a", "5");
    param.put("b", "true");
    param.put("c", "-3");

    // the value of the key "a" is a String representing a positive int so return it
    assertEquals(5, readPositiveIntParam(param, "a"));

    // returns zero since the value of the key "b" is not an int
    assertEquals(0, readPositiveIntParam(param, "b"));

    // returns zero since the value of the key "c" is an int but it is negative
    assertEquals(0, readPositiveIntParam(param, "c"));

    // returns zero since there is no key "d" in the map
    assertEquals(0, readPositiveIntParam(param, "d"));
}

int readPositiveIntParam(Map<String, String> params, String name) { 
String value = params.get(name);
if (value == null) return 0;
int i = 0;
try {
i = Integer.parseInt(value);
} catch (NumberFormatException nfe) { }
if (i < 0) return 0;
return i;
}

int readPositiveIntParam(Map<String, String> params, String name) {
    return asOption(params.get(name))
            .flatMap(FunctionUtils::stringToInt)
            .filter(i -> i > 0)
            .getOrElse(0);
}

import static Option.*;
public class FunctionUtils {
    public static Option<Integer> stringToInt(String s) {
        try {
            return some(Integer.parseInt(s));
        } catch (NumberFormatException nfe) {
            return none();
        }
    }
}