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方法终止。
