[英]How can I add to List<? extends Number> data structures?
我有一个声明如下的列表:
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> foo3
的通配符声明 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<? extends T>
因为你不能保证它真正指向什么样的List
,所以你不能保证该对象在那个List
是允许的。 唯一的“保证”是,你只能从它读,你会得到一个T
或子类T
。
反向逻辑适用于super
,例如List<? super T>
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<? super T>
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 的任何子类的列表,因此当您尝试将一个元素放入其中时,您不知道该元素实际上是否适合该列表。
例如, List 可能是一个Byte
列表,因此将Float
放入其中将是错误的。
“List '<' ? extends Number> 实际上是一个上限通配符!
上限通配符表示任何扩展 Number 或 Number 本身的类都可以用作形参类型:问题源于Java 不知道 List究竟是什么类型。 它必须是 EXACT 和 UNIQUE 类型。 我希望它有帮助:)
即使我在这里阅读了答案,也让我感到困惑,直到我找到了 Pavel Minaev 的评论:
请注意列表 < ? extends Number > 并不意味着“不同类型的对象列表,所有这些对象都扩展了 Number”。 它的意思是“扩展数字的单一类型的对象列表”
在此之后,我能够理解 BertF 很棒的解释。 列表 < ? 扩展数字 > 意味着 ? 可以是任何类型的扩展 Number(Integer, Double, etc) 并且它在声明中没有明确( List < ? extends Number > list )它是其中的哪一个,所以当你想使用 add 方法时,它不知道输入是否是是否相同类型; 到底是什么类型?
那么 List < 的元素? extends Number > 只能在构造时设置。
还要注意这一点:当我们使用模板时,我们是在告诉编译器我们正在处理的类型。 例如, T为我们保存了该类型,但不是? 做同样的事
我得说..这是要解释/学习的脏话之一
你可以这样做:
List<Number> foo3 = new ArrayList<Number>();
foo3.add(3);
您可以通过创建对具有不同类型的 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")
因为 3 是primitive (int)
,它不扩展Number
,您可以添加其装箱类型(Integer.valueOf(3))
。 虽然在IDEA
显示为错误,但是还是可以正常执行的。
从'Object'扩展列表的位置,您可以使用list.add;当要使用list.get时,只需要将Object转换为您的Object即可;
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.