Java类型系统中的一个漏洞？

Question

想象一下有一个名为 Simulator 的主类，它使用另外两个类-- Producers 和 Evaluators ，分别实现了IProducer和IEvaluator接口。

IProducer的实现产生结果，而IEvaluator的实现评估这些结果。Simulator通过查询IProducer的实现并将结果传递给IEvaluator实例来控制执行流程。

在运行时，Producer和Evaluator的实际实现是已知的，在编译时我只知道它们的接口。请查看以下示例。

package com.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

/**
 * Producers produce results. I do not care what their actual type is, but the
 * values in the map have to be comparable amongst themselves.
 */
interface IProducer<T extends Comparable<T>> {
    public Map<Integer, T> getResults();
}

/**
 * This example implementation ranks items in the map by using Strings.
 */
class ProducerA implements IProducer<String> {
    @Override
    public Map<Integer, String> getResults() {
        Map<Integer, String> result = new HashMap<Integer, String>();
        result.put(1, "A");
        result.put(2, "B");
        result.put(3, "B");

        return result;
    }
}

/**
 * This example implementation ranks items in the map by using integers.
 */
class ProducerB implements IProducer<Integer> {
    @Override
    public Map<Integer, Integer> getResults() {
        Map<Integer, Integer> result = new HashMap<Integer, Integer>();
        result.put(1, 10);
        result.put(2, 30);
        result.put(3, 30);

        return result;
    }
}

/**
 * Evaluator evaluates the results against the given groundTruth. All it needs
 * to know about results, is that they are comparable amongst themselves.
 */
interface IEvaluator {
    public <T extends Comparable<T>> double evaluate(Map<Integer, T> results,
            Map<Integer, Double> groundTruth);
}

/**
 * This is example of an evaluator, metric Kendall Tau-B. Don't bother with
 * semantics, all that matters is that I want to be able to call
 * r1.compareTo(r2) for every (r1, r2) that appear in Map<Integer, T> results.
 */
class KendallTauB implements IEvaluator {
    @Override
    public <T extends Comparable<T>> double evaluate(Map<Integer, T> results,
            Map<Integer, Double> groundTruth) {
        int concordant = 0, discordant = 0, tiedRanks = 0, tiedCapabilities = 0;

        for (Entry<Integer, T> rank1 : results.entrySet()) {
            for (Entry<Integer, T> rank2 : results.entrySet()) {
                if (rank1.getKey() < rank2.getKey()) {
                    final T r1 = rank1.getValue();
                    final T r2 = rank2.getValue();
                    final Double c1 = groundTruth.get(rank1.getKey());
                    final Double c2 = groundTruth.get(rank2.getKey());

                    final int ranksDiff = r1.compareTo(r2);
                    final int actualDiff = c1.compareTo(c2);

                    if (ranksDiff * actualDiff > 0) {
                        concordant++;
                    } else if (ranksDiff * actualDiff < 0) {
                        discordant++;
                    } else {
                        if (ranksDiff == 0)
                            tiedRanks++;

                        if (actualDiff == 0)
                            tiedCapabilities++;
                    }
                }
            }
        }

        final double n = results.size() * (results.size() - 1d) / 2d;

        return (concordant - discordant)
                / Math.sqrt((n - tiedRanks) * (n - tiedCapabilities));
    }
}

/**
 * The simulator class that queries the producer and them conveys results to the
 * evaluator.
 */
public class Simulator {
    public static void main(String[] args) {
        // example of a ground truth
        Map<Integer, Double> groundTruth = new HashMap<Integer, Double>();
        groundTruth.put(1, 1d);
        groundTruth.put(2, 2d);
        groundTruth.put(3, 3d);

        // dynamically load producers
        List<IProducer<?>> producerImplementations = lookUpProducers();

        // dynamically load evaluators
        List<IEvaluator> evaluatorImplementations = lookUpEvaluators();

        // pick a producer
        IProducer<?> producer = producerImplementations.get(0);

        // pick an evaluator
        IEvaluator evaluator = evaluatorImplementations.get(0);

        // evaluate the result against the ground truth
        double score = evaluator.evaluate(producer.getResults(), groundTruth);

        System.out.printf("Score is %.2f\n", score);
    }

    // Methods below are for demonstration purposes only. I'm actually using
    // ServiceLoader.load(Clazz) to dynamically discover and load classes that
    // implement interfaces IProducer and IEvaluator
    public static List<IProducer<?>> lookUpProducers() {
        List<IProducer<?>> producers = new ArrayList<IProducer<?>>();
        producers.add(new ProducerA());
        producers.add(new ProducerB());

        return producers;
    }

    public static List<IEvaluator> lookUpEvaluators() {
        List<IEvaluator> evaluators = new ArrayList<IEvaluator>();
        evaluators.add(new KendallTauB());

        return evaluators;
    }
}

这段代码可以在没有警告的情况下编译，并且运行结果也是正确的。这是我之前提问的问题的解决方案，因此这是一个后续问题。

使用上面的代码，想象一下您想将producer.getResults()调用的结果存储在一个变量中（稍后将在调用evaluator.evaluate(results, groundTruth)时使用该变量）。那个变量的类型是什么？ Map<Integer, ?>, Map<Integer, ? extends Comparable<?>>? 让主方法成为通用型并使用通用类型？到目前为止，我尝试的所有类型都不起作用。每种类型，编译器都会抱怨。

public static void main(String[] args) {
    // example of a ground truth
    Map<Integer, Double> groundTruth = new HashMap<Integer, Double>();
    groundTruth.put(1, 1d);
    groundTruth.put(2, 2d);
    groundTruth.put(3, 3d);

    // dynamically load producers
    List<IProducer<?>> producerImplementations = lookUpProducers();

    // dynamically load evaluators
    List<IEvaluator> evaluatorImplementations = lookUpEvaluators();

    // pick a producer
    IProducer<?> producer = producerImplementations.get(0);

    // pick an evaluator
    IEvaluator evaluator = evaluatorImplementations.get(0);

    // evaluate the result against the ground truth
    Map<Integer, ?> data = producer.getResults(); // this type works
    double score = evaluator.evaluate(data, groundTruth); // but now this call does not


    System.out.printf("Score is %.2f\n", score);
}

看起来producer.getResults()返回的内容在Java中无法静态地表达。这是一个bug吗，还是我漏掉了什么？

- David

---

为什么你不能只使用 evaluator.evaluate(producer.getResults(), groundTruth) 呢？ - Jeffrey

@Jeffrey，我可以使用它，但请想象您想在几个不同的评估器实例上调用evaluate(data, groundTruth) 使用相同的数据（这是从某个生成器实例返回的）。对于每个这样的调用，调用getResult并不明智，因为getResults通常包含大量计算。 - David

你尝试过使用没有泛型参数的Map吗？我知道这有点绕过了这个问题，但至少它应该能够编译和运行。然后，你只需要确保Map中有正确种类的元素。 - aroth

@David 好的，我为您发布了一个可能的解决方案作为答案。 - Jeffrey

Answer 1

这不是一个错误，而是一种限制。在类型系统社区中，众所周知的是Java带通配符的类型无法用Java语法表达。您的示例展示了这样一个情况，并且证明了通配符与F-bounded多态性（即形如T extends Something<T>的类型参数）本质上是不兼容的。

坦率地说，通配符是一种可怕的类型系统黑客。它们永远不应该被放入Java中。人们真正想要的，也是使您的示例可表达的，是适当的存在类型（其中通配符是有限的特定变体）。不幸的是，Java没有它们（尽管Scala有）。

- Andreas Rossberg

Answer 2

我的答案之前有一点要说明：你所有的>语句应该改成>，这样更灵活（你为什么要关心它是比较T还是Object？），而且这也是我的解决方案所必需的。

这并不是Java类型系统的一个“错误”，只是一个不方便的地方。Java不特别喜欢将交叉类型作为类型声明的一部分。

我发现绕过这个问题的一种方法是创建一个“不安全”的方法，在正常情况下永远不应该使用它：

@SuppressWarnings("unchecked")
private static <T extends Comparable<? super T>> Map<Integer, T> cast(Map<Integer, ?> map) {
    return (Map<Integer, T>) map;
}

请确保使用实际上是 Map<Integer, T extends Comparable<? super T>>（比如 IProducer 返回的那些）的 Map 调用此方法。

使用此方法，您可以执行以下操作：

IProducer<?> producer = ...
IEvaluator evaluator = ...
Map<Integer, ?> product = producer.getResults();
evaluator.evaluate(cast(product), truth);

然后Java将自动推断正确的类型参数。此外，“I”前缀在Java社区中通常被反对。

- Jeffrey

---

谢谢。一些评论：

• 应该使用@SuppressWarnings("unchecked")而不是@SuppressWarnings("unused")。
• 我有类似的东西，但是SuppressWarnings指令让我感到困扰——没有明显的原因，只是感觉我做错了什么。所以我试图找到更好的方法。我很惊讶自己碰到了语言限制/不便之处。
• PS：还要感谢您指出IInterface约定。我会放弃它。

- David

@David 啊，糟糕。我是手写这段代码的。只要你可以验证转换确实正确，抑制未经检查的警告就完全没问题。编译器并不聪明到为你做这件事，因为它会丢弃所有类型信息。作为程序员，你足够聪明去验证转换，因为你不必通过类型擦除来维护二进制兼容性。 - Jeffrey