纠正有界类类型可迭代和有界通配符列表字段迭代器类型

Question

我正在尝试找到正确的泛型和通配符排列来完成这项工作。类型已更改，所有其他代码已删除，以使其尽可能简单。

这里我有一个泛型类，其上限为Number，它实现了Iterable。它包含一个泛型类型的List。

我想传入任何Number 子类的List，并从List 字段返回该类型的Iterator。

这是显然行不通的基本想法。

class GenericQuestion<T extends Number> implements Iterable<T> {
    List<T> numbers;

    GenericQuestion(List<T> number) {
        this.numbers = number;
    }

    public Iterator<T> iterator() {
        return numbers.iterator();
    }

    static void main() {
        for (Number n : new GenericQuestion<Number>(new ArrayList<Integer>())) { // <---- error
            System.out.println(n.byteValue());
        }
    }
}

这给出了预期的错误

incompatible types: ArrayList<Integer> cannot be converted to List<Number>

上限通配符来拯救！差不多……

class GenericQuestion<T extends Number> implements Iterable<T> {
    List<? extends T> numbers;

    GenericQuestion(List<? extends T> number) {
        this.numbers = number;
    }

    public Iterator<T> iterator() {
        return numbers.iterator(); // <----- error
    }

    static void main() {
        for (Number n : new GenericQuestion<Number>(new ArrayList<Integer>())) {
            System.out.println(n.byteValue());
        }
    }
}

现在我对迭代器类型冲突感到困惑。

incompatible types: Iterator<CAP#1> cannot be converted to Iterator<T>
  where T is a type-variable:
    T extends Number declared in class GenericQuestion
  where CAP#1 is a fresh type-variable:
    CAP#1 extends T from capture of ? extends T

现在从逻辑上讲，我很确定将返回的迭代器强制转换为类型 (Iterator<T>) 是完全安全的， 但我宁愿以“正确”的方式做到这一点。我已经尝试了各种各样的事情。这是另一个绝望的尝试，但仍然没有成功。

class GenericQuestion<T extends Number> implements Iterable<T> {
    List<T> numbers;

    <U extends Number> GenericQuestion(List<U> number) {
        this.numbers = number; // <----- error
    }

    public Iterator<T> iterator() {
        return numbers.iterator();
    }

    static void main() {
        for (Number n : new GenericQuestion<Number>(new ArrayList<Integer>())) {
            System.out.println(n.byteValue());
        }
    }
}

错误。

incompatible types: List<U> cannot be converted to List<T>
  where U,T are type-variables:
    U extends Number declared in constructor <U>GenericQuestion(List<U>)
    T extends Number declared in class GenericQuestion

我认为也许辅助函数可以弥补差距，但我的尝试没有任何运气。

这似乎不应该那么难。强制施法真的可行吗？或者是否有一个通用声明可以让这一切一起工作？

Answer 1

对您的测试稍作改动，以免它试图强制GenericQuestion<Number>（而是让推断类型）：

for (Number n : new GenericQuestion<>(new ArrayList<Integer>())) {

您还可以更改 List 类型的可迭代声明，例如：

class GenericQuestion<T extends Number, L extends List<T>>
        implements Iterable<T> {

    private L numbers;

    GenericQuestion(L number) {
        this.numbers = number;
    }

Answer 2

如果你想在T 上出现差异，我认为你必须在某处有一些类型的不安全代码。

导致此限制的原因是Iterable<T>。它需要一个方法Iterator<T> iterator()。您不能确定您的Iterator<? extends T> 是否可以转换为Iterator<T>，因为唯一可能的情况是您的Iterator<? extends T> 在运行时是Iterator<T>。您可能已经明白，A<T> 无法转换为 A<U>，即使 T extends U。

如果您创建了自己的 MyIterable<T> 接口，则可以这样做：

class GenericQuestion<T extends Number> implements MyIterable<T> {
    List<? extends T> numbers;

    GenericQuestion(List<? extends T> number) {
        this.numbers = number;
    }

    public Iterator<? extends T> iterator() {
        return numbers.iterator();
    }

    static void main() {
        GenericQuestion<Number> q = new GenericQuestion<>(new ArrayList<Integer>());
        Iterator<? extends Number> iter = q.iterator();
        System.out.println(iter.next().byteValue());
    }
}

interface MyIterable<T> {
    Iterator<? extends T> iterator();
}

但正如您所见，您不能将 MyIterable 与 for 循环一起使用。

因此，您要么不允许new GenericQuestion<Number>(new ArrayList<Integer>())，要么编写类型不安全的代码。

Answer 3

我发现的另一个解决方案是使用基本类型的迭代器来包装通配符迭代器。我怀疑这在技术上是你应该如何处理这种情况的。

class GenericQuestion<T extends Number> implements Iterable<T> {
    List<? extends T> numbers;

    GenericQuestion(List<? extends T> number) {
        this.numbers = number;
    }

    public Iterator<T> iterator() {
        return new Iterator<T>() {
            Iterator<? extends T> iter = numbers.iterator();
            public boolean hasNext() {
                return iter.hasNext();
            }

            public T next() {
               return iter.next();
            }

            public void remove() {
                iter.remove();
            }
        };
    }

    static void main() {
        for (Number n : new GenericQuestion<Number>(new ArrayList<Integer>())) {
            System.out.println(n.byteValue());
        }
    }
}