Rx java 如何在RxJava中创建动态列表上的观察者？

我需要在不断变化（添加元素）的数组上创建一个观察者

我使用的是Obserable.from（Iterable），但它似乎在ArrayList上创建了Obserable，就像创建时一样

---

我需要在ArrayList每次添加新元素时通知观察者并执行操作。

好了。感谢RxJava谷歌集团的Dávid Karnok

import java.util.ArrayList；
导入java.util.List；
进口接收。可观察；
导入rx.subject.PublishSubject；
公共类可观察性示例{
公共静态类可观察列表{
受保护的最终清单；
受保护的最终出版主题为ADD；
公众观察者（）{
this.list=new ArrayList（）；
this.onAdd=PublishSubject.create（）；
}
公共无效添加（T值）{
列表。添加（值）；
onAdd.onNext（值）；
}
公共可观察的getObservable（）{
在ADD上返回；
}
}
公共静态void main（字符串[]args）引发异常{
ObservableList olist=新的ObservableList（）；
olist.getObservable（）.subscribe（System.out:：println）；
增加（1）；
睡眠（1000）；
增加（2）；
睡眠（1000）；
增加（3）；
}
}

您可以将两个观测值合并为一个。 其中一个可以是元素的初始列表，第二个可以是主题：

import rx.Observable;
import rx.subjects.ReplaySubject;
import java.util.ArrayList;
import java.util.List;

public class ExampleObservableList {
    public static void main(String[] args) {
        List<Integer> initialNumbers = new ArrayList<Integer>();
        initialNumbers.add(1);
        initialNumbers.add(2);

        Observable<Integer> observableInitial = Observable.from(initialNumbers);
        ReplaySubject<Integer> subject = ReplaySubject.create();

        Observable<Integer> source = Observable.merge(observableInitial, subject);

        source.subscribe(System.out::println);

        for (int i = 0; i < 100; ++i) {
            subject.onNext(i);
        }
    }

}

---

我会考虑基于行为主体的这种方法。 这与juanpavergara的解决方案不同，在订阅可观察对象时，onNext（）将立即发送给观察者

public class ObservableList<T> {

    protected final List<T> list;
    protected final BehaviorSubject<List<T>> behaviorSubject;

    public ObservableList(List<T> list) {
        this.list = list;
        this.behaviorSubject = BehaviorSubject.create(list);
    }

    public Observable<List<T>> getObservable() {
        return behaviorSubject;
    }

    public void add(T element) {
        list.add(element);
        behaviorSubject.onNext(list);
    }
}


private void main() {
    final List<Integer> list = new ArrayList<>();
    list.add(0);
    list.add(1);

    final ObservableList<Integer> olist = new ObservableList<>(list);

    olist.getObservable().subscribe(System.out::println);

    olist.add(2);
    olist.add(3);
}

公共类可观察列表{
受保护的最终清单；
受保护的最终行为主体行为主体；
公共观察列表（列表）{
this.list=列表；
this.behaviorSubject=behaviorSubject.create（列表）；
}
公共可观察的getObservable（）{
返回行为主体；
}
公共无效添加（T元素）{
列表。添加（元素）；
行为主体.onNext（列表）；
}
}
私有void main（）{
最终列表=新的ArrayList（）；
列表。添加（0）；
增加第（1）款；
最终可观察列表=新可观察列表（列表）；
olist.getObservable（）.subscribe（System.out:：println）；
增加（2）；
增加（3）；
}

---

在实现MVP时，当您希望观察系统中一个组件（即：一个存储库或数据源）返回的一个资源（即对象列表），并且希望观察者（即：演示者或交互者）时，此解决方案可能非常有用当一个元素添加到系统另一部分的列表中时收到通知。

您好，您可以使用ObserverXList在addAll上进行观察、添加、删除和更新列表

public class ObservableRxList<T> {
    protected final List<T> list;
    protected final PublishSubject<List<T>> subject;

     public ObservableRxList() {
         this.list = new ArrayList<T>();
         this.subject = PublishSubject.create();
     }

     public void add(T value) {
         list.add(value);
         subject.onNext(list);
     }

     public void addAll(List<T> value) {
         list.addAll(value);
         subject.onNext(list);
     }

     //not sure about this
     public void update(T value) {
         for (ListIterator<T> it = list.listIterator(); it.hasNext(); ) {
             if (value == it.next()) {
                 it.set(value);
                 break;
             }
         }
         subject.onNext(list);
     }

     public void update(int position, T value) {
         list.set(position, value);
         subject.onNext(list);
     }

     public void remove(T value) {
         list.remove(value);
         subject.onNext(list);
     }

     public void remove(int index) {
         list.remove(index);
         subject.onNext(list);
     }

     public Observable<List<T>> getObservable() {
         return subject;
     }

     public List<T> getCurrentList() {
         return list;
     }
 }

---

你在scala有这个例子吗？没有，先生。还没有。我会这样做，并让你知道：）伟大的答案，我发现这非常有用。我用update（）和remove（）方法扩展了您的解决方案：谢谢您的回答。如果您希望在一个观察者订阅时，观察者发出一个具有列表当前状态的onNext，您可以使用Behavior Subject。如果只使用私有静态PublishSubject publishListSubject，它会起作用吗？为什么使用Behavior Subject而不使用ReplaySubject？您是否错过了订阅之前添加的列表元素？@fdermishin

onNext（）

获取整个列表，而不仅仅是添加的元素。因此，您将在订阅时获得列表的当前状态。我得到

原因：不存在类型变量的实例，因此列表符合
上的observeOnSubscribe
。创建（列表）

public class ObservableRxList<T> {
    protected final List<T> list;
    protected final PublishSubject<List<T>> subject;

     public ObservableRxList() {
         this.list = new ArrayList<T>();
         this.subject = PublishSubject.create();
     }

     public void add(T value) {
         list.add(value);
         subject.onNext(list);
     }

     public void addAll(List<T> value) {
         list.addAll(value);
         subject.onNext(list);
     }

     //not sure about this
     public void update(T value) {
         for (ListIterator<T> it = list.listIterator(); it.hasNext(); ) {
             if (value == it.next()) {
                 it.set(value);
                 break;
             }
         }
         subject.onNext(list);
     }

     public void update(int position, T value) {
         list.set(position, value);
         subject.onNext(list);
     }

     public void remove(T value) {
         list.remove(value);
         subject.onNext(list);
     }

     public void remove(int index) {
         list.remove(index);
         subject.onNext(list);
     }

     public Observable<List<T>> getObservable() {
         return subject;
     }

     public List<T> getCurrentList() {
         return list;
     }
 }

mObservableRxList.getObservable().subscribe(productList-> {
    this.products.clear();
    this.products.addAll(productList;
    productAdapter.notifyDataSetChanged();
});