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响应的次数多。然后我的新Arraylist有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;
}

在这个函数中，我添加了由observable发出的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。

从RxJava开始，循环

5 个答案: