Question

我只是在练习RX Java，并希望在数组中找到与过滤器匹配的项目。我看不出任何明显的方法。我正在考虑可能压缩范围和可迭代的可观察的东西，但它很快变得比循环更冗长和复杂。

Answer 1

没有一种正确的方法可以做到这一点。塞缪尔的回答可以是一个。它还取决于你的阵列是什么以及你需要如何处理订户中的结果。

这是一个（java7）示例，其中Observer发出ArrayList<String>：

strings.map(new Func1<ArrayList<String>, ArrayList<Integer>>() {
            @Override
            public ArrayList<Integer> call(ArrayList<String> strings) {
                ArrayList<Integer> list = new ArrayList<>();
                for(String string: strings){
                    if(statement){
                        list.add(strings.indexOf(string));
                    }
                }
                return list;
            }
        }).subscribe(new Action1<ArrayList<Integer>>() {
            @Override
            public void call(ArrayList<Integer> integers) {
                doSomethingWithThePositions(integers);
            }
        });

以下是Observer每次从ArrayList中发出String的示例：

final ArrayList<String> strings1 = new ArrayList<>();
Observable.from(strings1)
        .filter(new Func1<String, Boolean>() {
            @Override
            public Boolean call(String s) {
                return !s.isEmpty();
            }
        })
        .subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                int i = strings1.indexOf(s);
                doSomethingWithThePosition(i);
            }
        });

Answer 2

我喜欢塞缪尔的回答。我已经编写了一个Transformer实现他的东西，符合Java 6/7并使用Long索引（我有很长的流来处理！）。

你这样称呼它：

Observable.just("a", "b").compose(MapWithIndex.<String>instance());

这是课程（源和单元测试here）：

package com.github.davidmoten.util;

import java.util.Iterator;

import rx.Observable;
import rx.Observable.Transformer;
import rx.functions.Func2;

import com.github.davidmoten.util.MapWithIndex.Indexed;

public final class MapWithIndex<T> implements Transformer<T, Indexed<T>> {

    private static class Holder {
        static final MapWithIndex<?> INSTANCE = new MapWithIndex<Object>();
    }

    @SuppressWarnings("unchecked")
    public static <T> MapWithIndex<T> instance() {
        return (MapWithIndex<T>) Holder.INSTANCE;
    }

    @Override
    public Observable<Indexed<T>> call(Observable<T> source) {

        return source.zipWith(NaturalNumbers.instance(), new Func2<T, Long, Indexed<T>>() {

            @Override
            public Indexed<T> call(T t, Long n) {
                return new Indexed<T>(t, n);
            }
        });
    }

    public static class Indexed<T> {
        private final long index;
        private final T value;

        public Indexed(T value, long index) {
            this.index = index;
            this.value = value;
        }

        @Override
        public String toString() {
            return index + "->" + value;
        }

        public long index() {
            return index;
        }

        public T value() {
            return value;
        }

    }

    private static final class NaturalNumbers implements Iterable<Long> {

        private static class Holder {
            static final NaturalNumbers INSTANCE = new NaturalNumbers();
        }

        static NaturalNumbers instance() {
            return Holder.INSTANCE;
        }

        @Override
        public Iterator<Long> iterator() {
            return new Iterator<Long>() {

                private long n = 0;

                @Override
                public boolean hasNext() {
                    return true;
                }

                @Override
                public Long next() {
                    return n++;
                }

                @Override
                public void remove() {
                    throw new RuntimeException("not supported");
                }
            };
        }

    }

}

优雅的方式来获得过滤器的索引或首先使用RX Java

2 个答案: