What's the difference between rxjava2's Maybe and Optional?

smallufo :

The doc says

Conceptually, it is a union of Single and Completable providing the means to capture an emission pattern where there could be 0 or 1 item or an error signalled by some reactive source.

But I am not sure what it truly means. It seems it is java8's Optional.

The following two codes have the same result , but I don't know what Maybe can do and Optional cannot (or cumbersome) do.

  @Test
  public void testMaybe1() {
    Observable.just(3, 2, 1, 0, -1)
      .map(i -> {
        try {
          int result = 6 / i;
          return Maybe.just(result);
        } catch (Exception e) {
          return Maybe.empty();
        }
      })
      .blockingForEach(maybe -> {
          logger.info("result = {}", maybe.blockingGet());
        }
      );
  }


  @Test
  public void testMaybe2() {
    Observable.just(3, 2, 1, 0, -1)
      .map(i -> {
        try {
          int result = 6 / i;
          return Optional.of(result);
        } catch (Exception e) {
          return Optional.empty();
        }
      })
      .blockingForEach(opt -> {
          logger.info("result = {}", opt.orElse(null));
        }
      );
  }

The results are the same :

result = 2
result = 3
result = 6
result = null
result = -6

In rxJava1 , My API used to return Observable<Optional<T>> , Is it a bad smell ? Should I change to Observable<Maybe<T>> ?

Praveer Gupta :

Maybe is a wrapper around an operation/event that may have either

A single result
No result
Error result

However Optional is a wrapper around a value that may either be

Present
Absent

In your example, in the map operation, the computation is synchronous (i.e. 6/i is synchronous and can result in a value immediately) and you want to propagate a value (if division is possible) or empty value (if division is not possible). Hence using Optional makes more sense.

There are however other options also:

If you want to propagate why division is not possible then you would want to report the exception that occurred. In such a case using Maybe will make more sense.
If you are not interested in both empty value and reason of error, then you simply want to skip propagating those results. In such a scenario I would use a flatMap instead of map. I will then not have to use any of Optional or Maybe.
```
.flatMap(i -> { 
  try { 
    int result = 6 / i; 
    return Observable.just(result); 
  } catch (Exception e) { 
    return Observable.empty(); 
  } 
}) 
```

Maybe is also useful when you have an Observable that can emit multiple values but you are interested in, let's say, only the first one and hence you use the firstElement() operator on the Observable. This returns a Maybe because either there is a single value, or there is no value (if source Observable does not emit any value before completing) or there is an error (if source Observable errors before emitting any value).

Guess you like

Origin http://10.200.1.11:23101/article/api/json?id=453746&siteId=1