List<?> list代表list里面在编译期检查时可以放任意类型
解决方案 »
- 传智播客“经典Java、PHP、Net、网页平面入门视频教程”DVD光盘赠送活动启动
- 数据结构作业
- org.hibernate.QueryException: could not resolve property: DownloadFile
- 急求关于JScrollPane+JTable的问题
- 如何通过反射,将一个字符串,转换为一个类?
- 看一下这段代码应该怎样改,最小的修改结构开线程播放声音
- 问个很很基础问题,关于字符串
- equals方法到底是否需要覆盖
- java应用的cpu占用率始终上不去
- 为什么我在网上下栽了j++builder7安装后没有组件可以用,是不是J++BUILDER7没有组件的
- 菜菜菜鸟问题
- java四则运算的实现,怎么把中缀式转为后缀式
比如直接List
List<?> 这个不管是什么,但是都是一样的。比如可以是List<Integer>,也可以是 List<String>,不管是什么,list里元素是一样的。
但List list里没有限制,同一个list里,list(0)可以是Iteger,而list(1)可以是String,即其每个元素可以不一样。
不写的话就是在eclipse里会有黄线警告而已。
E这种应该是所谓的带参的可以传递的,可以再次被引用,后面再用到E表示相同类型。
List<E>表示说list中可以任意E类型的对象这个E可以被你在声明中引用到
例如在方法中
public <E> void a(List<E> list){
E e=list.get(0);
后面再对着e对象可以做各种操作
}
但是如果是?的
就不能在引用了
public void a(List<?> list){
? e=list.get(0);//这样就不行了。也就自然不能在用e这个引用了
}
List<?> list = new ArrayList();
list.add("str");//出错,书中也提到了不能加入非null的值
list.add(null);//没错但是不明白这个一般会用到哪些情景中
就是说它返回的类型是不确定的?
而List<E>返回的类型是确定的。
应该是这么回事了
但是,像我上面说的,不知会在什么场景中使用到
但是就像List一样,要强转类型。
比如String s = (String) list.get(0);
现在我能想到的应用场景就是,只给读(get),不给写(add)。
我现在问的不是List<E>
而是问List<?>
import java.util.List;public class Hello {
public static void main(String[] args) {
List<?> listx = new LinkedList<?>(); // Error
List<?> listy = new LinkedList<Integer>(); // Ok List<Integer> list1 = new LinkedList<Integer>();
list1.add(1);
list1.add(2);
list1.add(3); List<String> list2 = new LinkedList<String>();
list2.add("A");
list2.add("B");
list2.add("C"); List list3 = new LinkedList();
list3.add(1);
list3.add("A");
list3.add(Hello.class); display(list1);
display(list2);
display(list3);
} public static void display(List<?> list) {
// list.add(1); // Error
System.out.println(list);
}
}
list1.add("str");
List<?> list2 = list1;也能看出点什么了
就是List<?> 可以代表一个非泛型的List.(18楼代码的26行).
那似乎是List<?>和List的区别是,前者限制写入,而后者允许写入,其他一样!麻烦 Inhibitory解释一下!谢谢!
你没有引用他,我帮你一下
Inhibitory,麻烦能否解释下22楼的疑问?
改成:public static void display(List list) {//把List<?>换成List
结果一样的。是否说明List类型可以代表任何泛型List呢?
但此时可以把注视掉的语句去掉注释,每个list都能加进去一个Integer 了,这样的话,list2显然被破坏了。所以List<?>不允许写入,这样保护了泛型的的规则。
可能问的不是很清楚,关键就是:
List<?> 和List除了前者限制写入外,没有其他区别?
我想官方代码的意思就List<?>相当于List<? extends Object>
而List<Object>已经定了只能传入Object.
但是,List<?>又和List<E>有什么区别呢?写入的区别?//Consider the following method, printList:public static void printList(List<Object> list) {
for (Object elem : list)
System.out.println(elem + " ");
System.out.println();
}
//The goal of printList is to print a list of any type, but it fails to achieve that goal — it prints only a list of Object instances; it cannot print List<Integer>, List<String>, List<Double>, and so on, because they are not subtypes of List<Object>. To write a generic printList method, use List<?>:public static void printList(List<?> list) {
for (Object elem: list)
System.out.print(elem + " ");
System.out.println();
}
//Because for any concrete type A, List<A> is a subtype of List<?>, you can use printList to print a list of any type:List<Integer> li = Arrays.asList(1, 2, 3);
List<String> ls = Arrays.asList("one", "two", "three");
printList(li);
printList(ls);//这样的话,如果调用List<Object>那个方法确实不行,但是为什么不用List<E>呢?
//----------------我的代码
public static <E> void printList(List<E> list) {
for (Object elem: list)
System.out.print(elem + " ");
System.out.println();
}
//这样的话,上面的结果也是可以打的
list.add("str");//出错,书中也提到了不能加入非null的值
E 是 formal type parameter 确定类型只是未知就是这样的区别我觉得
<?>意思是未知类型,就是不设上下限
<? extend Object>意思是继承于Object的未知类型
<? super Object>意思是Object的祖先类型
后面还可以用&接口名序列指定接口
<E>可以应用以上的格式,对于类,可以在类声明时指定泛型类型,对于方法可以通过参数传入<E>来确定运行时泛型类型
这个建议适用于任何发Java泛型疑问贴的同学,在论坛里见了不少对泛型有疑问的帖子,没有一个问题超出书里描述的范围。
泛型的限定;
? extends E: 可以接收E类型或者E的子类型。上限。
? super E: 可以接收E类型或者E的父类型。下限public static void printColl(Collection<? extends Person> al)
{
Iterator<? extends Person> it = al.iterator();
while(it.hasNext())
{
System.out.println(it.next().getName());
}
}
class Person
{
private String name;
Person(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
}
class Student extends Person
{
Student(String name)
{
super(name);
}
}
return "List";
}
public static String classify(List<E> lst){
return "List";
}
第二个应该编译不了吧
// 应该加上泛型声明
public static <E> String classify(List<E> lst){
return "List";
}
区别很细微……
首先第一个 List<?> 是只读的,如果你试图在方法内调用 lst.add(),只要不是 add(null) 都不能通过编译;
第二个可以用强转的方式add(),虽然可能会破坏类型安全。然后第二个方法是泛型方法,你在调用的时候可以指定具体类型,这个具体类型可以作为返回类型使用:
public static <E> E classify(List<E> lst){
return "List";
}// user code:
String s = ClassName.<String>classify(Arrays.asList("1","2","3"));
Integer i = ClassName.<Integer>classify(Arrays.asList(1, 2, 3));
例子中的 return 语句错了,不过意思你能明白就行了。
2.看明白你意思了。即用?不可以做为具体类型返回?但是感觉有点奇怪。这么做的用途是什么?
即声明List<?>,让你来用的话,你会用在什么场景?
没太看明白
如果你在编译前能确定类型就写<Type>,这样必须完全兼容Type类型才能传入,也就是静态的类型限定,<?>就是指定一个未知的Type,因为必须完全兼容才能传入,而未知类型与任何类型都不能完全兼容,所以只能匹配null值。
for (Object e : c) {
System.out.println(e);
}
}但又可以被E代替,貌似唯一性职能没有体现出来
我最近在学习这个泛型,有点体会,不知对否,不对的话,请指正!
1 ?这个通配符代表已知类型,他与 ? extends someClass, someClass是一样的,出现于使用某个已
经定义的泛型类,泛型方法或泛型接口中。
2 E 及E extends someClass 出现于定义泛型类,泛型接口,泛型方法中。
3 List<?> 和 List<E>是有本质的区别的。List<?>, 是在使用泛型类List,这个不管具体里面是什么,
但已经是一个明确的,可被赋值的类型了。可以给它赋值。
比如,List<?> listUnknown = null;
listUnknown = new ArrayList<Integer>();
或listUnknown = new LinkedList<String>();
等等。
但List<E> 它还不是一个已知的类,还不能被赋值。只能出现在定义泛型的方法中。(List已经是
被定义成泛型类了).如33楼,后面的代码,需加上<E> 类型声明。
return "List";
}
List<E> listUnknown1 = new ArrayList<Integer>();这里的E代表的恰恰是一个确定但未知的类型,所以编译不通过(因为E未必是Integer)
thinking in java P396..
我想官方代码的意思就List<?>相当于List<? extends Object>
而List<Object>已经定了只能传入Object.
但是,List<?>又和List<E>有什么区别呢?写入的区别?//Consider the following method, printList:public static void printList(List<Object> list) {
for (Object elem : list)
System.out.println(elem + " ");
System.out.println();
}
//The goal of printList is to print a list of any type, but it fails to achieve that goal — it prints only a list of Object instances; it cannot print List<Integer>, List<String>, List<Double>, and so on, because they are not subtypes of List<Object>. To write a generic printList method, use List<?>:public static void printList(List<?> list) {
for (Object elem: list)
System.out.print(elem + " ");
System.out.println();
}
//Because for any concrete type A, List<A> is a subtype of List<?>, you can use printList to print a list of any type:List<Integer> li = Arrays.asList(1, 2, 3);
List<String> ls = Arrays.asList("one", "two", "three");
printList(li);
printList(ls);//这样的话,如果调用List<Object>那个方法确实不行,但是为什么不用List<E>呢?
//----------------我的代码
public static <E> void printList(List<E> list) {
for (Object elem: list)
System.out.print(elem + " ");
System.out.println();
}
//这样的话,上面的结果也是可以打的List<?> 可以接收不定类型返回值,并且输出,例如:
public List<?> getRecListByDate(String loginName,Date dateStart,Date dateEnd,String Type) {
StringBuffer buffer = new StringBuffer();
buffer.append("select ");
buffer.append(Type);
buffer.append(" from tb_record where date >= :p1 and date <= :p2 and username = :p3 order by id");
Query query = createSqlQuery(buffer.toString(), new Parameter(dateStart,dateEnd,loginName));
return query.list();
//接收
List<?> records1 = new ArrayList<Double>();
records1 = getRecListByDate(token.getUsername(), formatDate.StringToDate(startDate), formatDate.StringToDate(endDate),Type);
前面的查询结果类型并不确定,接收是类型也是不确定的,这时候用List<?>可以接收到