java - 我的代码中的 在那里做什么？

Question

这是 my earlier problem 的延续.我的问题已经解决了，但我想进一步询问代码，我最好再开一个问题，因为我还需要问一些其他的事情。所以这是我的观察结果

public static <T> Observable<T> makeObservable(final Callable<T> func) {
        return Observable.create(
                new Observable.OnSubscribe<T>() {
                    @Override
                    public void call(Subscriber<? super T> subscriber) {
                        try {
                            T observed = func.call();
                            if (observed != null) { // to make defaultIfEmpty work
                                subscriber.onNext(observed);
                            }
                            subscriber.onCompleted();
                        } catch (Exception ex) {
                            subscriber.onError(ex);
                        }
                    }
                }).map(new Func1<T, T>() {
            @Override
            public T call(T t) {
                return null;
            }
        });

我不知道那个T在那里做什么？我试着用谷歌搜索，但我无法理解它在上面代码中的作用。官方 java 文档说它是“泛型类型是在类型上参数化的泛型类或接口(interface)”。试图进一步搜索它，我发现了 this question that confuses me even more .

除了需要真正理解那里的T，还需要知道如何使用.map来转换T的内容。从上面的代码来看，这段

.map(new Func1<T, T>() {
    @Override
    public T call(T t) {
        return null;
    }

是我添加的，因为我想尝试将 T 的内容更改为其他内容，也许更改为另一个对象。我该如何实现？在此之前，这是我对RxJava中.map函数的理解。

根据官方文档 http://reactivex.io/RxJava/javadoc/rx/Observable.html#map(rx.functions.Func1)它说，

public final <R> Observable<R> map(Func1<? super T,? extends R> func)
Returns an Observable that applies a specified function to each item emitted by the source Observable and emits the results of these function applications.

func - a function to apply to each item emitted by the Observable

我从上面的 func 定义中解释正确吗，第一个参数(super T)应该是“传入”数据类型，第二个参数(扩展 R)是“传出”数据类型，或者转换项的数据类型。因为这是我从大多数代码示例中看到的。例如，来自 http://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/

Observable.just("Hello, world!")
    .map(new Func1<String, Integer>() {
        @Override
        public Integer call(String s) {
            return s.hashCode();
        }
    })

我对上面代码的理解是 Func1 接收字符串并将其传递给 call(String s)，并返回 Integer，如 Func1<String, Integer> 中定义的那样.那么我上面的解释总是正确的吗？因为从我的第一个代码开始，我需要将 T 更改为其他内容，但是当我将 .map new Func1 的第二个参数更改为除 T 之外的任何其他内容时，Android Studio 将给我“不兼容类型”错误。

Answer 1

所以您现在正在处理泛型类型。你这里有一个通用的方法，所以它能够 makeObservable s 处理您在运行时传递给它的任何类型。 <T>将根据传递给方法的参数进行解析。

想要制作 Observable处理 Date ？ makeObservable(new Callable<Date>() {...});一个Observable的 String ？ makeObservable(new Callable<String>() {...});

请注意，由于您的代码的可观察流尚未转换输入数据，因此它会输出一个 Observable<T>。以及。另请注意，您的代码无法提前知道它可以调用的方法，因此它可以应用的可能转换将受到限制。

其中一个转换(又名 map )可能是获取 T 的字符串表示形式对象。

顺便说一句，是的，您在 map 中是正确的功能，T是输入类型，R输出类型，因此在您的代码中应用这样的映射将导致返回类型 makeObservable正在Observable<R> (将 R 替换为具体类型，您不能在此处泛化)。

public static <T> Observable<String> makeToStringObservable(final Callable<T> func) {
    return Observable.create(
            new Observable.OnSubscribe<T>() {
                @Override
                public void call(Subscriber<? super T> subscriber) {
                    try {
                        T observed = func.call();
                        if (observed != null) { // to make defaultIfEmpty work
                            subscriber.onNext(observed);
                        }
                        subscriber.onCompleted();
                    } catch (Exception ex) {
                        subscriber.onError(ex);
                    }
                }
            }).map(new Func1<T, String>() {
                @Override
                public String call(T t) {
                  //toString() is a method that is always there, yay
                  return t.toString();
            }
    });