如何添加到List<?ExtendedNumber>数据结构?

内容来源于 Stack Overflow,并遵循CC BY-SA 3.0许可协议进行翻译与使用

  • 回答 (2)
  • 关注 (0)
  • 查看 (13)

我有一个声明如下的List:

 List<? extends Number> foo3 = new ArrayList<Integer>();

我试图给foo3加3。但是,我收到如下错误消息:

The method add(capture#1-of ? extends Number) in the type List<capture#1-of ?
extends Number> is not applicable for the arguments (ExtendsNumber)
提问于
用户回答回答于

对不起,但你不能。

通配符声明List<? extends Number> foo3意味着变量foo3可以保存来自一系列类型的任何值(而不是任何特定类型的值)。这意味着任何这些都是法律任务:

List<? extends Number> foo3 = new ArrayList<Number>;  // Number "extends" Number
List<? extends Number> foo3 = new ArrayList<Integer>; // Integer extends Number
List<? extends Number> foo3 = new ArrayList<Double>;  // Double extends Number

所以,鉴于此,List foo3在上述任何可能的ArrayList分配之后,您可以添加哪种类型的对象将是合法的:

  • 你不能添加一个Integer因为foo3可能指向一个List<Double>
  • 你不能添加一个Double因为foo3可能指向一个List<Integer>
  • 你不能添加一个Number因为foo3可能指向一个List<Integer>

你不能添加任何对象,List<? extends T>因为你不能保证List它真正指向的是什么类型的,所以你不能保证该对象是允许的List。唯一的“保证”是你只能从中读取,你会得到一个T或一个子类T

反向逻辑适用于super,例如List<? super T>。这些是合法的:

List<? super Number> foo3 = new ArrayList<Number>; // Number is a "super" of Number
List<? super Number> foo3 = new ArrayList<Object>; // Object is a "super" of Number

你不能读取特定类型T(eg Number),List<? super T>因为你不能保证List它真正指向的是什么类型。您唯一的“保证”是您可以在不违反指向列表的完整性的情况下添加类型T(或其任何子类T)的值。

这方面的完美例子是Collections.copy()

public static <T> void copy(List<? super T> dest,List<? extends T> src)

请注意src列表声明如何extends使我能够通过相关列表类型的家族中的任何列表,并且仍然保证它将生成T类型或T的子类型的值。但是不能将其添加到src列表中。

dest列表声明使用super,让我从一个家庭相关的列表类型的通过任何名单,仍然保证我可以写一个特定类型T到该列表中的一个值。但是如果从列表中读取,则不能保证读取特定类型T 的值。

所以现在,感谢泛型通配符,我可以用这种单一方法完成以下任何调用:

// copy(dest, src)
Collections.copy(new ArrayList<Number>(), new ArrayList<Number());
Collections.copy(new ArrayList<Number>(), new ArrayList<Integer());
Collections.copy(new ArrayList<Object>(), new ArrayList<Number>());
Collections.copy(new ArrayList<Object>(), new ArrayList<Double());

考虑这个令人困惑和非常广泛的代码来锻炼你的大脑。注释掉的行是非法的,为什么要在行的最右边说明(需要滚动查看其中的一些):

  List<Number> listNumber_ListNumber  = new ArrayList<Number>();
//List<Number> listNumber_ListInteger = new ArrayList<Integer>();                    // error - can assign only exactly <Number>
//List<Number> listNumber_ListDouble  = new ArrayList<Double>();                     // error - can assign only exactly <Number>

  List<? extends Number> listExtendsNumber_ListNumber  = new ArrayList<Number>();
  List<? extends Number> listExtendsNumber_ListInteger = new ArrayList<Integer>();
  List<? extends Number> listExtendsNumber_ListDouble  = new ArrayList<Double>();

  List<? super Number> listSuperNumber_ListNumber  = new ArrayList<Number>();
//List<? super Number> listSuperNumber_ListInteger = new ArrayList<Integer>();      // error - Integer is not superclass of Number
//List<? super Number> listSuperNumber_ListDouble  = new ArrayList<Double>();       // error - Double is not superclass of Number


//List<Integer> listInteger_ListNumber  = new ArrayList<Number>();                  // error - can assign only exactly <Integer>
  List<Integer> listInteger_ListInteger = new ArrayList<Integer>();
//List<Integer> listInteger_ListDouble  = new ArrayList<Double>();                  // error - can assign only exactly <Integer>

//List<? extends Integer> listExtendsInteger_ListNumber  = new ArrayList<Number>(); // error - Number is not a subclass of Integer
  List<? extends Integer> listExtendsInteger_ListInteger = new ArrayList<Integer>();
//List<? extends Integer> listExtendsInteger_ListDouble  = new ArrayList<Double>(); // error - Double is not a subclass of Integer

  List<? super Integer> listSuperInteger_ListNumber  = new ArrayList<Number>();
  List<? super Integer> listSuperInteger_ListInteger = new ArrayList<Integer>();
//List<? super Integer> listSuperInteger_ListDouble  = new ArrayList<Double>();     // error - Double is not a superclass of Integer


  listNumber_ListNumber.add(3);             // ok - allowed to add Integer to exactly List<Number>

  // These next 3 are compile errors for the same reason:
  // You don't know what kind of List<T> is really
  // being referenced - it may not be able to hold an Integer.
  // You can't add anything (not Object, Number, Integer,
  // nor Double) to List<? extends Number>      
//listExtendsNumber_ListNumber.add(3);     // error - can't add Integer to *possible* List<Double>, even though it is really List<Number>
//listExtendsNumber_ListInteger.add(3);    // error - can't add Integer to *possible* List<Double>, even though it is really List<Integer>
//listExtendsNumber_ListDouble.add(3);     // error - can't add Integer to *possible* List<Double>, especially since it is really List<Double>

  listSuperNumber_ListNumber.add(3);       // ok - allowed to add Integer to List<Number> or List<Object>

  listInteger_ListInteger.add(3);          // ok - allowed to add Integer to exactly List<Integer> (duh)

  // This fails for same reason above - you can't
  // guarantee what kind of List the var is really
  // pointing to
//listExtendsInteger_ListInteger.add(3);   // error - can't add Integer to *possible* List<X> that is only allowed to hold X's

  listSuperInteger_ListNumber.add(3);      // ok - allowed to add Integer to List<Integer>, List<Number>, or List<Object>
  listSuperInteger_ListInteger.add(3);     // ok - allowed to add Integer to List<Integer>, List<Number>, or List<Object>
用户回答回答于

问题是,你不知道列表是什么清单。它可以是Number的任何子类的列表,所以当你试图将一个元素放入它时,你不知道该元素实际上是否适合列表。

例如,列表可能是Bytes 的列表,所以将它放入它将是一个错误Float

扫码关注云+社区