我的代码中的 <T> 在那里做什么？

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 文档说它是一个“泛型类型是一个泛型类或接口，它在类型上被参数化”。试图进一步搜索它，我找到了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

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

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

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

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

顺便说一句，是的，您在 map 函数中是正确的，T 是输入类型，R 是输出类型，因此在您的代码中应用这样的映射将导致返回类型为 @ 987654335@ 为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();
            }
    });

Answer 2

T 是您的泛型类型。这个链接应该有助于解释它：https://docs.oracle.com/javase/tutorial/java/generics/types.html

基本上，该类型将在运行时替换为真实类型，例如 String 或 Object。

如果您将 Func 的返回类型从 T 类型更改为其他类型，那么您还必须修改 Observable 泛型类型。这在map的定义中可以看出：Observable类型R与Func返回类型R是一致的。