the maybe class represents deferred response. maybe observable can emit either a single successful value or no value.

class declaration

following is the declaration for io.reactivex.single<t> class −

public abstract class maybe<t>
   extends object
      implements maybesource<t>

protocol

following is the sequential protocol that maybe observable operates −

onsubscribe (onsuccess | onerror | oncomplete)?

maybe example

create the following java program using any editor of your choice in, say, c:\> rxjava.

observabletester.java

import java.util.concurrent.timeunit;

import io.reactivex.maybe;
import io.reactivex.disposables.disposable;
import io.reactivex.observers.disposablemaybeobserver;
import io.reactivex.schedulers.schedulers;

public class observabletester {
   public static void main(string[] args) throws interruptedexception {
      //create an observer
      disposable disposable = maybe.just("hello world")
         .delay(2, timeunit.seconds, schedulers.io())
         .subscribewith(new disposablemaybeobserver<string>() {
         @override
         public void onerror(throwable e) { 
            e.printstacktrace();
         }

         @override
         public void onsuccess(string value) {
            system.out.println(value);
         }

         @override
         public void oncomplete() {
            system.out.println("done!");
         }
      }); 
      thread.sleep(3000);
      //start observing
      disposable.dispose();
   }
}

verify the result

compile the class using javac compiler as follows −

c:\rxjava>javac observabletester.java

now run the observabletester as follows −

c:\rxjava>java observabletester

it should produce the following output −

hello world