java泛型通配符

① java的Collection接口中的方法containAll()在定义泛型形参时，为什么要使用通配符

importjava.util.ArrayList;
importjava.util.Collection;

publicclassTest{

	publicstaticvoidmain(String[]args){
		acceptList1(newArrayList<String>());
		acceptList2(newArrayList<String>());
		acceptList3(newArrayList<String>());
	}
	
	//第一种方法是不推荐的，因为在支持泛型的地方没有指定泛型，会导致编译警告
	publicstaticvoidacceptList1(Collectionc){
	}
	
	//第二种方法，实际上就是接受任何种类的泛型，这正是该方法需要的
	publicstaticvoidacceptList2(Collection<?>c){
	}
	
	//第三种方法，编译警告，竟然不接受Object的子类
	publicstaticvoidacceptList3(Collection<Object>c){
	}
	
	//其实第三种方法可以写作Collection<?extendsObject>，但这是多此一举
}

任何一本教科书上都会说明，Java的泛型是伪泛型，编译后泛型信息会消除掉。

也就是所谓的泛型擦除，所以写了泛型和没写泛型差不错。

泛型只是一种语法糖，只是帮你存入时检查类型，取出时强制转型而已。

② java中什么是泛型，怎么用泛型

最简单的运用：List<String> list = new ArrayList<String>();
这个是什么意思？
意思就是list只装String类型的数据，别的，装不进去
然后你就会觉得这个好像有点封装的意思，比如LIst<Student>，封装学生类
所以，所谓泛型就是广泛的数据类型，你可以把它理解成封装

③ java泛型

java泛型是1.5引进的一个新概念.
本题对于"? super T"和"? extends T",我从书上摘个经典的例子给你看看,如果不能理解,那么你就参考以下书籍慢慢体会,循序渐进!

"? super T"和"? extends T",都是java泛型通配符,而用法又有区别,
还有super 和extends 不是java类关系中的超类和继承的意思,他是通配符的下限和上限限制.

下面看一个通配符得高级用法:
在这一部分，我们来考虑一些通配符得高级用法。我们已经看到了上限通配符在从一个数据结构中进行读取的几个例子。现在考虑相反的情况，一个只写的数据结构。

接口Sink是这种情况的一个简单例子。

interface Sink<T> {

void flush(T t);

}

我们可以想象他被如下面的代码一样使用。方法writeAll() 被设计来把集合coll的所有元素flush到sink snk，并且返回最后一个flush的元素。

public static <T> T writeAll(Collection<T> coll, Sink<T> snk) {

T last = null;

for (T t : coll) {

last = t;

snk.flush(last);

}

return last;

}

Sink<Object> s;

Collection<String> cs;

String str = writeAll(cs, s); // 非法的调用!!

像上面所写，writeAll() 的调用是非法的，因为没有有效的类型参数可以被推断出来。String 或 Object都不是T的合适的类型，因为Collection的元素和 Sink的元素必须是同样的类型。

我们可以解决这个问题，通过使用通配符来修改writeAll()的方法签名，如下：

<T> T writeAll(Collection<? extends T> coll, Sink<T> snk) { … }

String str = writeAll(cs, s); //可以调用但是返回值类型错误

这个调用现在是合法的，但是赋值产生错误，因为推断出的返回值类型是 Object因为T 匹配了Sink的类型，Object。

解决方案是使用一种我们还没有见过的有限制的通配符：有下限的通配符。语法 ? super T 表示T的一个未知的父类（或者是T自己）。这跟我们用? extends T 表示T的一个未知的子类是对应的。

<T> T writeAll(Collection<T> coll, Sink<? super T> snk) { … }

String str = writeAll(cs, s); // YES!!!

使用这个语法，这个调用是合法的，推断出来的T是String，正是我们想要的。

现在让我们看一个更现实的例子。一个 java.util.TreeSet<E> 代表一个有序的元素是E类型的树。创建一个TreeSet的一个方法是传递一个 Comparator 对象给构造函数。这个Comparator将会用来按照需要对TreeSet进行排序。

TreeSet(Comparator<E> c)

Comparator 接口是核心：

interface Comparator<T> { int compare(T fst, T snd); }

假定我们要创建一个 TreeSet<String> 并传递一个合适的 Comparator，我们需要传一个能比较String的Comparator。这可以是一个 Comparator<String>，也可以是一个 Comparator<Object>。然而我们不能用Comparator<Object>来调用上面的构造函数。我们可以使用一个有下限的通配符来得到我们需要的灵活性：

TreeSet(Comparator<? super E> c)

这允许任何可用的Comparator被传递进去。

作为使用下限通配符最终的例子，让我们来看看方法 Collections.max()，它返回一个集合中的最大的元素。

现在，为了让max()能工作，传进来的集合中的所有元素必须实现 Comparatable接口。而且，他们必须都能够被彼此比较（all be comparable to each other）。第一个尝试是：

public static <T extends Comparable<T>> T max(Collection<T> coll)

就是说，方法的参数是某一个能和自己进行比较的T的集合。这限制太严格了。

为什么？考虑一个能和任何对象进行比较的类型：

class Foo implements Comparable<Object> {...} ...

Collection<Foo> cf = ...;

Collections.max(cf); // 应该能工作

cf 中的每个元素都可以和每个cf中的其他元素进行比较，因为每个这样的元素都是一个Foo,它可以和任意的对象进行比较，也可以和另一个Foo进行比较。

但是，使用上面的方法签名，我们发现这个调用被拒绝。推断出来的类型必须是Foo，但是Foo没有实现接口 Comparable<Foo>。

T 精确的(exactly)和自己能比较是不需要的。所需要的是 T能够和它的父类中的一个进行比较，这导出：（注：Collections.max()的实际方法签名更复杂，我们在第10部分再讨论。）

public static <T extends Comparable<? super T>> T max(Collection<T> coll)

这个推论对大多数想让 Comparable 对任意类型生效的用法中都有效：你总是应该使用 Comparable<? super T>。

总之，如果你有一个只使用类型参数T作为参数的API，它的使用应该利用下限通配符( ? super T )的好处。相反的，如果API只返回T，你应该使用上限通配符( ? extends T )来给你的客户端更大的灵活性。

（原文：This reasoning applies to almost any usage of Comparable that is intended to work for arbitrary types: You always want to use Comparable<? super T>.

In general, if you have an API that only uses a type parameter T as an argument, its uses should take advantage of lower bounded wildcards (? super T). Conversely, if the API only returns T, you'll give your clients more flexibility by using upper bounded wildcards (? extends T). ）。

如果你想比较深刻的了解java泛型那么
建议你看看<Java1.5泛型指南>
中文链接地址:http://blog.csdn.net/explorers/archive/2005/08/15/454837.aspx#_Toc111865968
英文pdf格式地址:http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf

④ java泛型之泛型通配符具体是什么作用

Java中不允许嵌套泛型的内层通配符?匹配一个具体的类型，因为这可能破坏类型安全。
这样做是可以的：
List<?> list = new ArrayList<Integer>();
而这样做是不可以的：
List<List<?>> list = new ArrayList<List<Integer>>();

⑤ java通配符类型

• 如果是类引入的通配符，那么指的是”*“，

如：import java.util.*;表示的是引入util包下的所有类；

• 如果是查找的通配符，那么指的是”*“，

如：*.java;表示的是查找后缀为java的所有文件；

• 如果是泛型中的通配符，那么指的是”<T>“;

如：List<T> list = new ArayList<T>()；表示定义了一个通配的list对象，可以代表任何对象的list。

⑥ java中E，T，的区别

java泛型中E和T是可以随便起名的，只是大家习惯用E和T，一传十十传百大家一看到<E>和<T>就知道是泛型了，所以这只是习惯使然。比如：

是不影响运行的。

至于？，？是用于定义泛型的通配符和边界，一般比较常见的是<? extends T>，可以参考一下这篇资料

⑦ java 集合中泛型通配符 用了之后就不能添加 元素了 为什么

首先泛型是用来约束的（或者说是规范化），泛型的本质是参数化类型，不是用来通配的（这个说法也不完全对），这个概念一定不要混淆了。

你添加的元素是String类型的，那么你的代码就得这样：

ArrayList<String>arr=newArrayList<String>();

或者：

List<String>arr=newArrayList<String>();//多态，推荐使用

再或者：

Listarr=newArrayList();
ArrayListarr=newArrList();//这两种没有用泛型，编译器会提示警告

用上面1和2方式的话，你的arr集合就只能存放String类型对象，3没有用泛型，什么类型的对象都可以存放。只是取出来的时候，会要类型转换，这个过程很容易出错。

希望我的回答能对你有所帮助，荣幸之至。

⑧ 你真的了解JAVA中的泛型E、T、K、V吗

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许开发者在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

但是如果换成其他的字母代替 T ，在可读性上可能会弱一些。通常情况下，T，E，K，V，？是这样约定的：？表示不确定的 java 类型。T (type) 表示具体的一个java类型。K V (key value) 分别代表java键值中的Key Value。E (element) 代表Element。