RxJava 1.x from()和just()用法、区别和举例

RxJava 1.x 中的 Observable.from 和 Observable.just 用于将Java 面向对象中的数据转换为 RxJava 中的数据单元。

一、from

RxJava 1.x from用于转换多个数据，比如 ArrayList等包含多个数据的数组或者列表。
RxJava 1.x 包含了5个 Observable.from 的重载方法：

public static <T> Observable<T> from(Iterable <? extends T> iterable)

public static <T> Observable<T> from(T[] array)

public static <T> Observable<T> from(Future<? extends T> future)

public static <T> Observable<T> from(Future<? extends T> future, long timeout, TimeUnit unit) 

public static <T> Observable<T> from(Future<? extends T> future, Scheduler scheduler)  

二、just

RxJava 1.x 包含了10个 Observable.just 的重载方法：
RxJava 1.x 中的 Observable.just 用于创建仅有一个的数据对象。

public static <T> Observable<T> just(final T value)

public static <T> Observable<T> just(T t1, T t2)

public static <T> Observable<T> just(T t1, T t2, T t3)

public static <T> Observable<T> just(T t1, T t2, T t3, T t4)

public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5)

public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5, T t6)

public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5, T t6, T t7)

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

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

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)

三、from和just的区别

from和just的区别
- 1、from用于转换多个数据，比如 ArrayList等包含多个数据的数组或者列表;
- 2、而 just 只用于处理单个的数据。

会不会有人有疑问？just 明明提供了10个重载的方法，最多可以接受10个参数啊！

四、from和just的相互转换

如果from的转换数组中只包含一个数据，就是just的情况。
如果just 多于一个数据，就是from的情况。

看看源代码就一目了然：

1、from 遇到只包含一个数据的时候，会使用just创建Observable

 public static <T> Observable<T> from(T[] array) {
        int n = array.length;
        if (n == 0) {
            return empty();
        } else
        if (n == 1) {
            return just(array[0]);
        }
        return unsafeCreate(new OnSubscribeFromArray<T>(array));
    }

2、just 遇到多于一个的情况，会使用from 创建 Observable

public static <T> Observable<T> just(T t1, T t2) {
        return from((T[])new Object[] { t1, t2 });
    }

public static <T> Observable<T> just(T t1, T t2, T t3) {
        return from((T[])new Object[] { t1, t2, t3 });
    }

public static <T> Observable<T> just(T t1, T t2, T t3, T t4) {
        return from((T[])new Object[] { t1, t2, t3, t4 });
    }

...

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) {
        return from((T[])new Object[] { t1, t2, t3, t4, t5, t6, t7, t8, t9, t10 });
    }

所以，使用的时候，可以根据需要和习惯使用这两个方法。

五、使用举例

1、读取List数据

List<String> list = Arrays.asList(
     "blue", "red", "green", "yellow", "orange", "cyan", "purple"
   );
   Observable<String> listObservable = Observable.from(list);
listObservable.subscribe(System.out::println);

2、读取文件内容

Path resources = Paths.get("src", "main", "resources");
   try (DirectoryStream<Path> dStream
   =Files.newDirectoryStream(resources)) {
     Observable<Path> dirObservable = Observable.from(dStream);
     dirObservable.subscribe(System.out::println);
   }catch (IOException e) {
  e.printStackTrace();
}

3、读取数组

   Observable<Integer> arrayObservable =
     Observable.from(new Integer[] {3, 5, 8});
     arrayObservable.subscribe(System.out::println);

4、单个字符

Observable.just('S').subscribe(System.out::println);

5、多个字符

Observable
     .just('R', 'x', 'J', 'a', 'v', 'a')
     .subscribe(System.out::print,
       System.err::println,
       System.out::println
);

6、类数据

   public static class User {
     private final String forename;
     private final String lastname;
     public User(String forename, String lastname) {
       this.forename = forename;
       this.lastname = lastname;
     }
     public String getForename() {
       return this.forename;
     }
     public String getLastname() {
       return this.lastname;
     }
}

Observable
     .just(new User("Dali", "Bali"))
     .map(u -> u.getForename() + " " + u.getLastname())
     .subscribe(System.out::println);