从RxJava开始，循环

Question

谁能告诉我如何改变java的默认代码:

   private ArrayList<RateItem> generateRates(List<Rates> ratesList){
    rateItemArrayList=new ArrayList<RateItem>();
    for(Rates rates : ratesList)
        rateItemArrayList.add(new RateItem(rates.getName(),rates.getCode(),rates.getValue()));
    return rateItemArrayList;
}

在RxJava代码?我刚刚开始，我还不能处理基本的

编辑

我不知道为什么这个循环迭代的次数比我的List from response的次数多。那么我的新数组列表有1300个元素，而不是30个。怎么了?

 private Observable<ArrayList<RateItem>> generateRates(List<Rates> rates){
    rateItemArrayList = new ArrayList<RateItem>();
    Observable<ArrayList<RateItem>> observable = Observable.from(rates)
            .map(new Func1<Rates, ArrayList<RateItem>>() {
                @Override
                public ArrayList<RateItem> call(Rates rat) {
                    for(Rates ratt : rates)
                        rateItemArrayList.add(new RateItem(ratt.getName(),ratt.getCode(),ratt.getValue()));
                    return rateItemArrayList;
                }
            });
    return observable;
}

@Weava我不知道，但我不能让你的代码，AS自动生成代码像上面。

Answer 1

private Observable<RateItem> generateRates(List<Rates> ratesList){
   return Observable
     .from(ratesList)
     .map(rates -> new RateItem(rates.getName(),rates.getCode(),rates.getValue());
}

实际上，我甚至会跳过实际使用的List<anything>(不是模块间api，而是模块内协调)，在这种情况下，整个方法变成一个简单的调用:

.map(rates -> new RateItem(rates.getName(),rates.getCode(),rates.getValue());

实际上，我想说的是将构造函数重构为RateItem中的一个单独的静态方法，最好是一个构造函数，然后就是

.map(RateItem::new);

Answer 2

在RxJava中，您可以使用from和map函数这样做。

private Observable<List<RateItem>> generateRates(List<Rates> ratesList) {
    Observable<List<RateItem>> myObservable = Observable.from(ratesList)
            .map(new Func1<List<Rates>, List<RateItem>>() {
                @Override
                public List<RateItem> call(List<Rates> rateList) {
                    List<RateItem> items = new ArrayList<>();
                    for(Rates rates : ratesList) {
                        items.add(new RateItem(rates.getName(), rates.getCode(), rates.getValue()));
                    }
                    return items;
                }
            });
      return myObservable;
}

在这个函数中，我添加了由可观察对象发出的ratesList对象。然后，在发出列表时，将其映射到List<RateItem>对象。然后，只要在调用此方法的任何地方返回用于订阅的Observable。

如果你正在使用RetroLamda，你绝对可以让这个看起来更好一点(参见@njzk2的评论)，但我想展示实际发生了什么。

作为一个如何订阅你的新Observalbe的例子，它看起来像这样:

    generateRates(new ArrayList<Rates>()).subscribe(new Func1<List<RateItem>>(){
        @Override
        public void call(List<RateItem> rateItems) {
            // Do whatever it is you need to do with your list
        }
    });

Answer 3

我写了这段代码，我认为这可以工作，但我没有测试它。希望这能帮助你开始RxJava:

List<Rates> ratesList;
List rateItemArrayList = new ArrayList<RateItem>();
Observable.just(ratesList)
        .flatMap(new Func1<List<Rates>, Observable<RateItem>>() {
            @Override
            public Observable<RateItem> call(List<Rates> rate) {
                return Observable.just(new RateItem(rate.getName(), rate.getCode(), rate.getValue()));
            }
        }).subscribe(new Action1<RateItem>() {
    @Override
    public void call(RateItem rateItem) {
        rateItemArrayList.add(rateItem);
    }
});

Answer 4

另一种方式，我创建了这个单元测试

class RateItem {
    String name;
    String code;
    public RateItem(String name, String code) {
        this.name = name;
        this.code = code;
    }
}
class Rate {
    String name;
    String code;
    public Rate(String name, String code) {
        this.name = name;
        this.code = code;
    }
}
@Test
public void migrateToObservable() {
    generateRates(Arrays.asList(new Rate("a", "1"), new Rate("b", "2")));
}
private List<RateItem> generateRates(List<Rate> ratesList) {
    return  Observable.from(ratesList)
            .map(rate-> new RateItem(rate.name, rate.code))
            .toList().toBlocking().first();
}

如果您想看一些RXJava示例，请查看这里https://github.com/politrons/reactive

Answer 5

另一种不需要太多改变的方法是使用Observable.defer(generateRates());，它将把你的旧代码转换成Observable。