Single

Single<T> is essentially an Observable<T> that will only emit one item. It works just like an Observable, but it is limited only to operators that make sense for a single emission. It has its own SingleObserver interface as well:

    interface SingleObserver<T> {
    void onSubscribe(Disposable d);
    void onSuccess(T value);
    void onError(Throwable error);
    }

The onSuccess() essentially consolidates onNext() and onComplete() into a single event that accepts the one emission. When you call subscribe() against a Single, you provide the lambdas for onSuccess() as well as an optional onError():

    import io.reactivex.Single;

    public class Launcher {
    
      public static void main(String[] args) {
        Single.just("Hello")
          .map(String::length)
          .subscribe(System.out::println, 
        Throwable::printStackTrace);
      }
    }

Certain RxJava Observable operators will yield a Single, as we will see in the next chapter. For instance, the first() operator will return a Single since that operator is logically concerned with a single item. However, it accepts a default value as a parameter (which I specified as Nil in the following example) if the Observable comes out empty: 

    import io.reactivex.Observable;

     public class Launcher {
  
      public static void main(String[] args) {
        Observable<String> source = 
        Observable.just("Alpha","Beta","Gamma");

        source.first("Nil") //returns a Single
          .subscribe(System.out::println);
       }
     }

The output is as follows:

    Alpha

The Single must have one emission, and you should prefer it if you only have one emission to provide. This means that instead of using Observable.just("Alpha"), you should try to use Single.just("Alpha") instead. There are operators on Single that will allow you to turn it into an Observable when needed, such as toObservable().

If there are 0 or 1 emissions, you will want to use Maybe.