如何添加到 List<?扩展 Number> 数据结构？答案

【问题标题】：How can I add to List<? extends Number> data structures?如何添加到 List<?扩展 Number> 数据结构？
【发布时间】：2011-02-16 03:29:40
【问题描述】：

我有一个这样声明的列表：

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

我尝试将 3 添加到 foo3。但是我收到这样的错误消息：

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> 并不意味着“不同类型的对象列表，所有这些对象都扩展 Number”。它的意思是“扩展Number的single类型的对象列表”。
你最好检查 PECS 规则，生产者扩展，消费者超级。 stackoverflow.com/questions/2723397/…
列表 temp= Arrays.asList(3);

标签： java generics

【解决方案1】：

你不能（没有不安全的演员表）。您只能从中读取。

问题是您不知道列表到底是什么。它可能是 Number 的任何子类的列表，因此当您尝试将一个元素放入其中时，您并不知道该元素实际上是否适合该列表。

例如，列表可能是Bytes 的列表，因此将Float 放入其中会出错。

【讨论】：

【解决方案2】：

你可以这样做：

  List<Number> foo3 = new ArrayList<Number>();      
  foo3.add(3);

【讨论】：

【解决方案3】：

对不起，你不能。

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

因此，鉴于此，在上述任何可能的ArrayList 分配之后，您可以向List foo3 添加什么类型的对象是合法的：

您无法添加Integer，因为foo3 可能指向List<Double>。
您不能添加Double，因为foo3 可能指向List<Integer>。
您不能添加Number，因为foo3 可能指向List<Integer>。

你不能向List<? extends T>添加任何对象，因为你不能保证它真正指向的是哪种List，所以你不能保证那个@987654337中允许该对象@。唯一的“保证”是您只能从中读取，您将获得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

您无法从List<? super T> 中读取特定类型T（例如Number），因为您无法保证它真正指向的是哪种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 的值写入该列表。但是如果我从列表中读取，则不能保证读取到 specific 类型 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>

【讨论】：

为什么我们可以写`List extends Number> foo3 = new ArrayList();` 如果我们不能将一个元素进一步添加到这个列表中？
@articlestack：添加并不是列表唯一有用的事情。填充列表后，从列表中读取可能会很有用。通用通配符允许编写通常适用于一系列列表的代码，例如适用于 List 或 List。例如，查看 Collection.copy() 的签名。 src List 参数使用 extends 从 src 列表中读取，而 dest List 参数使用 super 写入 dest 列表。这允许一种方法可以从List<Integer> 或List<Double> 复制到List<Number> 或List<Object>。
Bert F，对于迟到的评论感到抱歉。您的文章中是否有错字，“添加类型 T（或 T 的子类）的值”应改为（或 T 的超类）？
@Vortex - or subclass of T 是正确的。例如，我不能将Object（Number 的超类）添加到List<? super Number> foo3，因为foo3 可能已分配为：List<? super Number> foo3 = new ArrayList<Number>（只能包含Number 或Number 的子类） . <? super Number> 指的是可以分配给foo3 的List<>s 的类型——而不是可以从中添加/读取的东西的种类。可以从foo3 中添加/删除的东西必须是可以从any 类型的List<> 中添加/删除的东西，可以分配给foo3。
我阅读了这篇文章以及所有后面的 cmets，因为 Java 泛型的考虑很糟糕，因为预期使用它的人无法很好地理解它，无法清楚地解释它。

【解决方案4】：

"List ' 实际上是一个上限通配符！

上限通配符表示任何扩展 Number 或 Number 本身的类都可以用作形参类型：问题源于 Java 不知道 List 到底是什么类型。它必须是 EXACT 和 UNIQUE 类型。我希望它有帮助:)

【讨论】：

【解决方案5】：

尽管我在这里阅读了答案，但我一直感到困惑，直到我找到 Pavel Minaev 的评论：

注意列表并不意味着“对象列表不同的类型，所有这些都扩展了数字”。它的意思是“列表的扩展 Number 的单一类型的对象"

在此之后，我能够理解 BertF 很棒的解释。列表意味着？可以是扩展 Number(Integer, Double, etc) 的任何类型，并且它的 not clearified 在声明（ List list ）中是它们中的哪一个，所以当你想使用 add 方法时不知道输入是否相同type；到底是什么类型？

那么 List 只能在构造时设置。

还要注意这一点：当我们使用模板时，我们是在告诉编译器我们正在处理什么类型。例如，T 为我们保留该类型，但 ? 不为我们保留该类型

我得说..这是要解释/学习的肮脏之一

【讨论】：

【解决方案6】：

您可以通过创建对具有不同类型的 List 的引用来伪造它。

（这些是 sepp2k 提到的“不安全强制转换”。）

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

// This will not compile
//list.add(100);

// WORKS, BUT NOT IDEAL
List untypedList = (List)list;
// It will let you add a number
untypedList.add(200);
// But it will also let you add a String!  BAD!
untypedList.add("foo");

// YOU PROBABLY WANT THIS
// This is safer, because it will (partially) check the type of anything you add
List<Number> superclassedList = (List<Number>)(List<?>)list;
// It will let you add an integer
superclassedList.add(200);
// It won't let you add a String
//superclassedList.add("foo");
// But it will let you add a Float, which isn't really correct
superclassedList.add(3.141);
// ********************
// So you are responsible for ensuring you only add/set Integers when you have
// been given an ArrayList<Integer>
// ********************

// EVEN BETTER
// If you can, if you know the type, then use List<Integer> instead of List<Number>
List<Integer> trulyclassedList = (List<Integer>)(List<?>)list;
// That will prevent you from adding a Float
//trulyclassedList.add(3.141);

System.out.println("list: " + list);

因为untypedList、superclassedList 和trulyclassedList 只是对list 的引用，所以您仍将向原始ArrayList 添加元素。

您实际上不需要在上面的示例中使用 (List<?>)，但您可能需要在代码中使用它，具体取决于您获得的 list 的类型。

请注意，使用 ? 会给你编译器警告，直到你把它放在你的函数之上：

@SuppressWarnings("unchecked")

【讨论】：

感谢您的精彩回答！我有一个特殊情况，我的代码语义保证强制转换是安全的。我只需要 Java 编译器停止引发错误...

【解决方案7】：

因为 3 是primitive (int)，它没有扩展Number，所以可以添加它的盒装类型(Integer.valueOf(3))。虽然在IDEA中显示为错误，但依然可以正常执行。

【讨论】：