The create() method gives the developer the ability to create an Observable from scratch. It takes an OnSubscribe object, which extends Action1, as a parameter and executes the call() function when an Observer subscribes to our Observable:

Observable
        .create(new Observable.OnSubscribe<Object>() {
            @Override
            public void call(Subscriber<? super Object> subscriber) {

            }
        });

Observable communicates with the Observer using the subscriber variable and by calling its methods according to the conditions. Let's see a real-world example:

Observable<Integer> observableString = Observable.create(new Observable.OnSubscribe<Integer>() {
    @Override
    public void call(Subscriber<? super Integer> observer) {

        for (int i = 0; i < 5; i++) {
            observer.onNext(i);
        }
        
        observer.onCompleted();
    }
});

Subscription subscriptionPrint = observableString.subscribe(new Observer<Integer>() {
    @Override
    public void onCompleted() {
        System.out.println("Observable completed");
    }

    @Override
    public void onError(Throwable e) {
        System.out.println("Oh no! Something wrong happened!");
    }

    @Override
    public void onNext(Integer item) {
        System.out.println("Item is " + item);
    }
});

The example is kept simple on purpose, because even if it's the first time you see RxJava in action, I want you to be able to figure out what's going on.

We created a new Observable<Integer> item that executes a for loop on five elements, emitting them one by one, and then it completes.

On the other side, we subscribe to the Observable, obtaining a Subscription object. The moment we subscribe, we start to receive integers and we print them one by one. We don't know how many integers we will receive. Indeed, we don't need to know because we provided behaviors for every possible scenario:

In the previous example, we created a sequence of integers and emitted them one by one. What if we already have a list? Can we save the for loop but still emit items one by one?

In the following code example, we create an Observable sequence from a list we already had:

List<Integer> items = new ArrayList<Integer>();
items.add(1);
items.add(10);
items.add(100);
items.add(200);

Observable<Integer> observableString = Observable.from(items);
Subscription subscriptionPrint = observableString.subscribe(new Observer<Integer>() {
    @Override
    public void onCompleted() {
        System.out.println("Observable completed");
    }
    @Override
    public void onError(Throwable e) {
        System.out.println("Oh no! Something wrong happened!");
    }

    @Override
    public void onNext(Integer item) {
        System.out.println("Item is " + item);
    }
});

The output is absolutely the same as that in the previous example.

The from() creator can create an Observable from a list/array, emitting every object contained in the list/array one by one or from a Java Future class, emitting the result value of the .get() method of the Future object. Passing Future as parameter, we can even specify a timeout value. The Observable will wait for a result from Future; if no result comes before the timeout, the Observable will fire the onError() method and notify the Observer that something was wrong.

What if we already have a classic Java function and we want to transform it in an Observable? We could use the create() method, as we already saw, or we can avoid a lot of boilerplate code using something like this:

Observable<String> observableString = Observable.just(helloWorld());

Subscription subscriptionPrint = observableString.subscribe(new Observer<String>() {
    @Override
    public void onCompleted() {
        System.out.println("Observable completed");
    }

    @Override
    public void onError(Throwable e) {
        System.out.println("Oh no! Something wrong happened!");
    }

    @Override
    public void onNext(String message) {
        System.out.println(message);
    }
});

The helloworld() function is super easy, like this:

private String helloWorld() {
    return "Hello World";
}

However, this could be any function we want. In the previous example, the moment we create the Observable, just() executes the function and when we subscribe to our Observable, it emits the returned value.

The just() creator can take between one and nine parameters. It will emit them in the same order as they are given as parameters. The just() creator also accepts lists or arrays, like from(), but it won't iterate on the list, emitting every value, it will just emit the whole list. Usually, it's used when we want to emit a defined set of values, but if our function is not time-variant, we can use just() to have a more organized and testable code base.

As a final note about the just() creator, after emitting the value, the Observable terminates normally. For the previous example, we will have two messages on the system console: "Hello World" and "Observable completed".

If for any reason we need an Observable emitting nothing but terminating normally, we can use empty(). We can use never() to create an Observable emitting nothing and never terminating, and we can use throw() to create an Observable emitting nothing and terminating with an error.