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);