RxJava: Cách chuyển đổi Danh sách đối tượng thành Danh sách đối tượng khác

Question

Tôi có Danh sách các SourceObject và tôi cần phải chuyển đổi nó thành Danh sách ResultObjects.

Tôi có thể lấy một đối tượng khác phương pháp sử dụng của ResultObject:

convertFromSource(srcObj); 

dĩ nhiên là tôi có thể làm điều đó như thế này:

public void onNext(List<SourceObject> srcObjects) { 
    List<ResultsObject> resObjects = new ArrayList<>(); 
    for (SourceObject srcObj : srcObjects) { 
     resObjects.add(new ResultsObject().convertFromSource(srcObj)); 
    } 
} 

nhưng tôi sẽ rất trân trọng cho những người có thể hiển thị cách thực hiện tương tự bằng cách sử dụng rxJava.

Answer 1

Nếu Observable của bạn phát ra một List, bạn có thể sử dụng các nhà khai thác:

• flatMapIterable (chuyển đổi danh sách của bạn đến một Quan sát các hạng mục)
• map (chuyển đổi mục của bạn để mục khác)

• toList toán tử (chuyển một Quan sát hoàn thành thành Quan sát phát ra danh sách các mục từ Hoàn thành có thể quan sát)

  Observable<SourceObjet> source = ... 
  source.flatMapIterable(list -> list) 
       .map(item -> new ResultsObject().convertFromSource(item)) 
       .toList() 
       .subscribe(transformedList -> ...); 
  

Answer 2

Bạn có thể sử dụng toán tử map. Ví dụ, nếu bạn có danh sách s các số nguyên và bạn muốn chuyển đổi vào danh sách s của đôi:

List<Integer> li = new ArrayList<>(); 
    Observable.just(li).map(l -> { 
     List<Double> lr = new ArrayList<Double>(); 
     for(Integer e:l) { 
      lr.add(e.doubleValue()); 
     } 
     return lr; 
    }); 

Nhưng tất cả đó là rất nhiều tự nhiên hơn nếu bạn có thể kiểm soát các quan sát và thay đổi nó để quan sát đơn thay vì các bộ sưu tập. Cùng một mã có thể chuyển đổi các yếu tố số nguyên duy nhất vào những đôi:

Observable.just(1,2,3).map(elem -> elem.doubleValue()) 

Answer 3

Phương pháp Observable.from() factory cho phép bạn chuyển đổi một tập hợp các đối tượng vào một dòng quan sát được. Khi bạn có một luồng, bạn có thể sử dụng toán tử map để chuyển đổi từng mục được phát ra. Cuối cùng, bạn sẽ phải đăng ký vào các kết quả quan sát ở để sử dụng các mục chuyển:

// Assuming List<SourceObject> srcObjects 
Observable<ResultsObject> resultsObjectObservable = Observable.from(srcObjects).map(new Func1<SourceObject, ResultsObject>() { 
    @Override 
    public ResultsObject call(SourceObject srcObj) { 
     return new ResultsObject().convertFromSource(srcObj); 
    } 
}); 

resultsObjectObservable.subscribe(new Action1<ResultsObject>() { // at this point is where the transformation will start 
    @Override 
    public void call(ResultsObject resultsObject) { // this method will be called after each item has been transformed 
     // use each transformed item 
    } 
}); 

Các phiên bản rút gọn nếu bạn sử dụng lambdas sẽ trông như thế này:

Observable.from(srcObjects) 
    .map(srcObj -> new ResultsObject().convertFromSource(srcObj)) 
    .subscribe(resultsObject -> ...); 

Answer 4

Đừng phá vỡ chuỗi, giống như thế này.

Observable.from(Arrays.asList(new String[] {"1", "2", "3", })) 
.map(s -> Integer.valueOf(s)) 
.reduce(new ArrayList<Integer>, (list, s) -> { 
    list.add(s); 
    return list; 
}) 
.subscribe(i -> { 
    // Do some thing with 'i', it's a list of Integer. 
}); 

Answer 5

Nếu bạn muốn duy trì Lists phát ra bởi nguồn Observable nhưng chuyển đổi các nội dung, tức là Observable<List<SourceObject>> để Observable<List<ResultsObject>>, bạn có thể làm một cái gì đó như thế này:

Observable<List<SourceObject>> source = ... 
source.flatMap(list -> 
     Observable.fromIterable(list) 
      .map(item -> new ResultsObject().convertFromSource(item)) 
      .toList() 
      .toObservable() // Required for RxJava 2.x 
    ) 
    .subscribe(resultsList -> ...); 

Điều này đảm bảo một cặp vợ chồng của sự vật:

• Số lượng Lists phát ra bởi các Observable được duy trì. I E.nếu nguồn phát ra 3 danh sách, sẽ có 3 danh sách chuyển đổi ở đầu bên kia
• Sử dụng Observable.fromIterable() sẽ đảm bảo các nội Observable chấm dứt để toList() thể được sử dụng