RxJava操作符-创建

Just：

public static <T> Observable<T> just(T value)
...
public static <T> Observable<T> just(T t1,
                     T t2,
                     T t3,
                     T t4,
                     T t5,
                     T t6,
                     T t7,
                     T t8,
                     T t9,
                     T t10)

接受1到10个items作为ta的参数，然后返回一个新的Observable按照参数（也就是那1到10个items）传入的顺序emit这些items，最后complete。

From：

public static <T> Observable<T> from(T[] array)
public static <T> Observable<T> from(java.lang.Iterable<? extends T> iterable)
public static <T> Observable<T> from(java.util.concurrent.Future<? extends T> future)
public static <T> Observable<T> from(java.util.concurrent.Future<? extends T> future, Scheduler scheduler)
public static <T> Observable<T> from(java.util.concurrent.Future<? extends T> future, long timeout,java.util.concurrent.TimeUnit unit)

接受一个Future、Iterable或者Array的实例作为参数。当接受的是一个Iterable或者Array实例时，返回的Observable将会emit在Iterable或Array实例中的元素。当接受的是Future实例时，返回的Observable将emit这个Future实例get方法返回的结果，也可以传入时间和时间单位的参数，当指定时间到了，而调用Future实例的get方法还没有返回结果，返回的Observable就会以一个错误终止。

Repeat：

public final Observable<T> repeat()
public final Observable<T> repeat(long count)
public final Observable<T> repeat(Scheduler scheduler)
public final Observable<T> repeat(long count, Scheduler scheduler)

返回的Observable无限次重复或者指定重复n次释放由原始Observable释放的items序列。默认repeat在trampoline Scheduler上运行，当然也可以指定Scheduler。

repeatWhen：

public final Observable<T> repeatWhen(Func1<? super Observable<? extends java.lang.Void>,? extends Observable<?>> notificationHandler)
public final Observable<T> repeatWhen(Func1<? super Observable<? extends java.lang.Void>,? extends Observable<?>> notificationHandler, Scheduler scheduler)

这个操作符有点复杂。ta的作用就是在一定条件下重新订阅原始的Observable并镜像ta释放的items，然后再emit这些镜像的items。这个条件就是，当原始的Observable由于onCompleted终止时，将把一个释放空类型items的Observable当作参数传入Func1的实现中，这个Func1的实现返回一个Observable，如果这个Observable也emit了items，那么就重新订阅原始的Observable并镜像ta释放的items，最后emit这些镜像的items。如果返回的这个Observable终止（onCompleted or onError）了，那么也就不重新订阅原始的Observable了。注意，这个Func1每次订阅只调用一次。

Create：

public static <T> Observable<T> create(Observable.OnSubscribe<T> f)

//给个例子吧
Observable.create(new Observable.OnSubscribe<Integer>() {
    @Override
    public void call(Subscriber<? super Integer> observer) {
        try {
            if (!observer.isUnsubscribed()) {
                for (int i = 1; i < 5; i++) {
                    observer.onNext(i);
                }
                observer.onCompleted();
            }
        } catch (Exception e) {
            observer.onError(e);
        }
    }
 } ).subscribe(new Subscriber<Integer>() {
        @Override
        public void onNext(Integer item) {
            System.out.println("Next: " + item);
        }

        @Override
        public void onError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }

        @Override
        public void onCompleted() {
            System.out.println("Sequence complete.");
        }
    });

没什么好说的，很原始的创建一个Observable的方法。需要注意一点的就是，最好在传入的OnSubscribe中调用isUnsubscribed方法，判断是否被订阅了，然后决定是否调用onNext方法。更环保嘛:-)

Defer：

public static <T> Observable<T> defer(Func0<Observable<T>> observableFactory)

当有新的Observer订阅时，返回的Observable调用Func0实现创建一个新的Observavle供Observer订阅。因此Observer实际订阅的Observable是由这个Func0实现决定的。这个操作符最大的好处就是只有当Observer订阅时才会释放items，而不像just、from等创建Observable的时候就开始释放items。

Range：

public static Observable<java.lang.Integer> range(int start,  int count)
public static Observable<java.lang.Integer> range(int start, int count, Scheduler scheduler)

接受两个参数，一个作为释放的整数序列的起始值，一个作为释放items的个数，创建一个Observable，这个Observable会emit一定数量的整数，这些整数以传入的起始值开始，以后依次加一。如果传入的释放items个数的参数为零，返回的Observable就不会释放items，如果是负数将导致异常。

Interval：

public static Observable<java.lang.Long> interval(long interval, java.util.concurrent.TimeUnit unit)
public static Observable<java.lang.Long> interval(long interval, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
public static Observable<java.lang.Long> interval(long initialDelay, long period, java.util.concurrent.TimeUnit unit)
public static Observable<java.lang.Long> interval(long initialDelay, long period, java.util.concurrent.TimeUnit unit, Scheduler scheduler)

创建一个Observable每隔一段固定时间emit一个整数，以零开始，之后依次加一。默认是在computation Scheduler上执行。

Timer：

public static Observable<java.lang.Long> timer(long delay, java.util.concurrent.TimeUnit unit)
public static Observable<java.lang.Long> timer(long delay, java.util.concurrent.TimeUnit unit,  Scheduler scheduler)

创建一个Observable在订阅后指定时间间隔后emit一个item，然后结束（completed）。默认在computation Scheduler上执行。

Empty、Never、Error：

public static <T> Observable<T> empty() #创建一个Observable不释放任何items而是立即调用*onCompleted*方法终止。
public static <T> Observable<T> never() #这家伙够牛，创建一个Observable不释放items也不给订阅ta的Observer发出任何通知，就这么那个什么。
public static <T> Observable<T> error(java.lang.Throwable exception) #返回一个Observable，当有Observer订阅ta时直接调用Observer的onError方法终止。