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

Posted 2023-02-25

【中文标题】如何添加到 List<?扩展 Number> 数据结构？

【英文标题】：How can I add to List<? extends Number> data structures?

【发布时间】：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 规则，生产者扩展，消费者超级。 ***.com/questions/2723397/…

列表 temp= Arrays.asList(3);

【参考方案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中显示为错误，但依然可以正常执行。