如何使用带有通配符的集合和泛型？

Question

首先我将尝试解释这段代码背后的想法。 我有一堆类（Processors）可以处理某种类型的其他类（Processables）。我有一个处理器列表，可以按特定顺序执行它们。我有一个地图，它将检索我要为某个处理器处理（Processables）的数据。 它看起来像这样。

public abstract class AbstractProcessable {
    ...
}

public class DummyProcessable extends AbstractProcessable {
   ...
}

public abstract class AbstractProcessor<T extends AbstractProcessable> {
    public abstract void process(List<T> listOfProcessables);
}

public class DummyProcessor extends AbstractProcessor<DummyProcessable> {

    @Override
    public void process(List<DummyProcessable> listToProcess) {
        ...
    }
}

到目前为止，这似乎工作正常。没有编译错误。但现在我有一个类似如下的类：

public class RandomClass {

    private List<AbstractProcessor<? extends AbstractProcessable>> processors;

    private Map<Class<? extends AbstractProcessor>, List<? extends AbstractProcessable>> data;

    public RandomClass() {
        processors = new ArrayList<>();
        processors.add(new DummyProcessor());

        data = new HashMap<>();
        data.put(DummyProcessor.class, new ArrayList<DummyProcessable>());

        processAll();
    }

    private void processAll() {
        for (AbstractProcessor<? extends AbstractProcessable> processor : processors) {
            List<? extends AbstractProcessable> dataToProcess;
            dataToProcess = data.get(processor);
            processor.process(dataToProcess); // compile error
        }
    }
}

编译错误：

    The method process(List<capture#4-of ? extends AbstractProcessable>) in the type AbstractProcessor<capture#4-of ? extends AbstractProcessable> is not applicable for the arguments (List<capture#5-of ? extends AbstractProcessable>)

我知道它可能有点难以阅读，但我尽量简化它。我对泛型也不是很好，所以也许我用错了一些通配符？ 谁能帮我解决这个问题？

提前非常感谢！

Answer 1

我怀疑这里的问题是：

1. ? extends AbstractProcessable 来自 private List<AbstractProcessor<? extends AbstractProcessable>> processors; 和
2. ? extends AbstractProcessable 来自List<? extends AbstractProcessable> dataToProcess;

不是同一类型。 ? extends AbstractProcessable 表示 AbstractProcessable 的未知子类，没有什么强制这两个未知数应该相同（这就是为什么会出现错误，因为未知数：capture#4-of ? 与未知数：capture#5-of ? 不同）。 不确定RandomClass 的用途，但我会将其更改为<T extends AbstractProcessable> 并使用T 定义列表和地图。这样列表和地图将具有相同的类型。

Answer 2

如果我正确理解你的问题，我前段时间问过a similar one。简短的回答是您不能以您想要的方式使用这样的地图。好消息是你不需要它;)

问题在于 Java 泛型是编译时的东西（您可能已经知道），它们只存在于编译时，而当您实际填写 List 时，不是。你找不到用 Java 表达你的想法的方法，即使它看起来完全合法。

您可能会发现Super Type Tokens 在某些情况下可用于提取参数，并避免用户在合适的情况下提供显式参数（不过请注意the limitations 并考虑它们是否真的可以增加一些价值）。

简而言之，您最终会得到一个类似的字段

private Map<Class<?>, List<?>> data;

（或者您可以为此使用Guava's Multimap 实现），使用一些强制转换并喊出一些警告，并依靠您的程序逻辑来确保客户端代码的类型安全。我在我的代码中使用了这种方法，到目前为止它从未失败过。

这是我的代码。我认为这正是您的情况，只需将 Subscriber<T> 和 Message 替换为您的 Processor<T> 和 Processable

public class MessageBus {

    public enum Action {
        CREATE, REMOVE, UPDATE, DELETE;
    }

    private static Map<Class<?>, Set<Subscriber<?>>> subscriptions;

    static {
        subscriptions = new HashMap<Class<?>, Set<Subscriber<?>>>();
    }

    @SuppressWarnings("unchecked")
    public static <T> void publish(T message, Action action) {
        Set<Subscriber<?>> set = getSubscribersFor(message.getClass());

        if (set == null)
            return;

        for (Subscriber<?> subscriber: set) {
            ((Subscriber<T>) subscriber).onMessage(message, action);
        }
    }

    public static <T> void subscribe(Class<T> type, Subscriber<T> subscriber) {
        Set<Subscriber<?>> set = getSubscribersFor(type);

        if (set == null) {
            set = new HashSet<Subscriber<?>>();
            subscriptions.put(type, set);
        }

        set.add(subscriber);
    }

    public static <T> void unsuscribe(Class<T> type, Subscriber<T> subscriber) {
        Set<Subscriber<?>> set = getSubscribersFor(type);
        set.remove(subscriber);
    }

    private static Set<Subscriber<?>> getSubscribersFor(Class<?> topic) {
        return subscriptions.get(topic);
    }
}

Answer 3

对我来说，听起来您在其中导入了 2 个不同的 List 类。检查导入部分并确保

import java.util.List

在两者中（或您需要的任何列表类型）

就像第一个猜测一样，没有详细检查您的代码:)