ReactiveX/RxJava

When I use Observable.fromArray(array).flatMap(element-> fromCallable(() -> element.value) and element.value is null flatMap swalows the error and continues, but if I change just this: fromCallable(() -> element.value).doOn*() throws the exception.

I'm wondering if this is the RxJava 2 expected behavior, here is the code:

public class FlatMapExample {
static class Pair<K extends Object, V extends Object> {
        private final K key;
        private final V value;

        Pair(K key, V value) {
            this.key = key;
            this.value = value;
        }

        public K getKey() {
            return key;
        }

        public V getValue() {
            return value;
        }
    }

    public static void main(String[] args) {
        Pair<String, String> ONE = new Pair<>("1", "ONE");
        Pair<String, String> TWO = new Pair<>("2", null);
        Pair<String, String> THREE = new Pair<>("3", "THREE");
        Pair<String, String> FOUR = new Pair<>("4", "FOUR");

        Pair[] array = {ONE, TWO, THREE, FOUR};

        withoutOnXOperator(array); 

        sleep(5L);

        withOnXOperator(array); //Throw error

        sleep(5L);
    }
    /**
    /* Throw errors
    */
    private static void withOnXOperator(Pair[] array) {
        System.out.println("With doOn* Operators");
        Observable.fromArray(array)
                .flatMap(
                        pair -> Observable.fromCallable(() -> pair.getValue())
                                .doOnNext(notification -> System.out.println("Event: " + notification)) //Apply doOn* operator
                )
                .cast(String.class)
                .subscribe(new PrintObserver("With doOn*"));
    }

    /**
    /* Doesn't throw errors
    */
    private static void withoutOnXOperator(Pair[] array) {
        System.out.println("Without doOn* Operators*");
        Observable.fromArray(array)
                .flatMap(pair -> Observable.fromCallable(() -> pair.getValue()))
                .cast(String.class)
                .subscribe(new PrintObserver("Without doOn*"));
    }

    static class PrintObserver implements Observer<String> {
        private final String name;

        PrintObserver(String name) {
            this.name = name;
        }

        @Override
        public void onSubscribe(Disposable d) {
            System.out.println(name + " Subscribed!");
        }

        @Override
        public void onNext(String s) {
            System.out.println(name + " onNext: " + s);
        }

        @Override
        public void onError(Throwable e) {
            System.out.println(name + " error: " + e.getMessage());
        }

        @Override
        public void onComplete() {
            System.out.println(name + " Done!");
        }
    }

    private static void sleep(long seconds) {
        try {
            Thread.sleep(seconds * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}