一、泛型上限
1、迭代并打印集合中的元素
（1）集合即可能是List，也可能是Set，用Collection提高扩展性
（2）当容器中存放的元素不确定，且里面不准备使用具体类型的情况下，使用通配符
注：
（1）通配符：?，未知类型。不明确类型时，可以用?来表示，意味着什么类型都可以传入
（2）运行时，参数中的泛型<>只要有一个类型具备了，里面就都是统一类型
/**
* 迭代并打印集合中的元素
* （1）使用Collection提高扩展性
* （2）容器中存放的元素不确定，且里面不准备使用具体的类型，使用通配符?，意味着什么类型都可以传入
*/
public static void printCollection(Collection<?> coll){
for (Iterator<?> it = coll.iterator(); it.hasNext(); ){
// String str = it.next(); //不使用具体的类型
//不能明确类型
System.out.println(it.next());
}
}2、<T>与<?>的区别
（1）<T>：如果有指定<T>，就意味着<T>能代表一个具体类型，并能被操作（<T>可以被接收）
（2）<?>：仅在不明确类型，且不对返回值类型进行操作时，用?来表示。调用的是Object中的方法 -- 用得较多
/**
* 返回值类型：T
*/
public static <T> T method(Collection<T> coll){
Iterator<T> it = coll.iterator();
T t = it.next(); //返回值为T，T这个类型是可以被操作的
return t;
} 3、学生类继承自Person类（class Student extends Person），但在Collection中，Person是一个单独的类型，Student也是一个单独的类型。Collection<>只能存一个具体的类型。如果Collection<Person>类型的参数接收的是存储Student类型元素的集合，即Collection<Person> coll = new ArrayList<Student>();，左右两边泛型不匹配（一般情况下，写泛型要具备的特点是：左右两边泛型要一致），编译报错。本来容器想装Person，结果new的只能装Student，其他的Person子类装不了，不合适
//Collection<Person>：只能接收存储Person对象的集合
public static void method(Collection<Person> coll){
Iterator<Person> it = coll.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
}
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<Student>();
list.add(new Student("zhangsan"));
list.add(new Student("xiaoqi"));
// method(list); //编译报错。method()方法的参数 Collection<Person>：Person是一个单独的类型，Student也是一个单独的类型
}想要接收Person的子类对象，Collection<? extends Person>，即 ?全都是来自Person的子类
//Collection<? extends Person>：只能接收存储Person或Person子类的集合 -- 泛型的限定
public static void method(Collection<? extends Person> coll){
Iterator<? extends Person> it = coll.iterator();
while (it.hasNext()){
Person p = it.next(); //存入的都是Person或Person子类，可以用Person接收（此处是多态）
System.out.println(p.getName()); //多态，方法 编译看左边，运行看右边
// System.out.println(it.next());
}
}
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<Student>();
list.add(new Student("zhangsan"));
list.add(new Student("xiaoqi"));
method(list);
ArrayList<String> list1 = new ArrayList<String>();
list1.add("abc1");
list1.add("abc2");
// method(list1); //编译报错，只能接收存储Person或Person子类的集合
}4、Collection<? extends Xxx>：只接收Xxx类型或者Xxx类型的子类 -- 泛型的限定（上限）。取出时，用Xxx类型接收，此时是多态（调用方法：编译看左边，运行看右边）
注：Collection<?> <==> Collection<? extends Object>
二、泛型下限
1、对类型进行限定
（1）? extends E：接收E类型或者E的子类型对象 -- 上限（扩展性较强，使用较多）
（2）? super E：接收E类型或者E的父类型对象 -- 下限（此种做法不是很多）
2、迭代器的泛型一定和获取迭代器对象集合的泛型一致
//Collection<? super Student>：只能接收存储Student或Student父类（Person）的集合，不能接收存储Worker的集合 -- 下限
//此种做法不多（应用不明显）
public static void method(Collection<? super Student> coll) {
//迭代器的泛型一定和获取迭代器对象集合的泛型一致
Iterator<? super Student> it = coll.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}三、上限的体现
1、boolean addAll(Collection<? extends E> c)：将指定collection中的所有元素都添加到此Collection中（扩展性很强）
class MyCollection<E> {
//在明确类型E的情况下，添加的就是已知类型E。但一次添加一个 比较慢
public void add(E e) {
}
//集合中装什么类型，在添加新集合的时候，新集合也是什么类型
// public void add(MyCollection<E> e) {
// }
//Collection中addAll()方法的实现原理
//存元素时使用上限（<? extends E>），扩展类型。取出时，不存在类型安全隐患
public void addAll(MyCollection<? extends E> e) {
}
}2、一般在存储元素时使用上限（? extends E）。因为一旦确定好类型，存入的就都是E或E的子类，取出时都按照上限类型E来运算，不会出现类型安全隐患
注：上限使用较多（可以扩展类型）
/*
ArrayList list1 = new ArrayList();
list1.add(new Person("zhangsan"));
ArrayList list2 = new ArrayList();
list1.add("abc");
//没有指定泛型，是Object，什么都可以存入。取出时，类型会存在安全隐患（类型不匹配）
list1.add(list2);
*/
ArrayList<Person> list1 = new ArrayList<Person>();
list1.add(new Person("zhangsan"));
ArrayList<Student> list2 = new ArrayList<Student>();
list2.add(new Student("xiaoqi"));
ArrayList<String> list3 = new ArrayList<String>();
list3.add("abc");
//addAll(Collection<? extends E> c)：取出时，按Person类型来取，Peron可以接收学生等子类，不存在类型安全隐患
list1.addAll(list2);
// list1.addAll(list3); //错误。类型不匹配四、下限的体现
1、TreeSet的部分构造函数
（1）TreeSet(Collection<? extends E> c)
（2）TreeSet(Comparator<? super E> comparator)
2、Student extends Person，若想按照姓名排序，需自定义比较器。无论是Student还是Person，用的都是同一段代码，只是泛型不同而已，且用的都是父类型Person的方法
class CompByName implements Comparator<Person> {
@Override
public int compare(Person p1, Person p2) {
int temp = p1.getName().compareTo(p2.getName());
return temp == 0 ? p1.getAge() - p2.getAge() : temp;
}
}
class CompByStuName implements Comparator<Student> {
@Override
public int compare(Student p1, Student p2) {
int temp = p1.getName().compareTo(p2.getName());
return temp == 0 ? p1.getAge() - p2.getAge() : temp;
}
}若想对Student、Worker统一地进行共性类型排序，怎么排？
Student、Worker的排序方式依赖于Person的排序方式。比较有一个特点，要把集合中的元素取出来比较存放位置。要把集合中的元素取出来进行比较，就要把取出来的元素进行接收。接收时，存放的是什么类型不重要，最重要的是接收进来的类型要大一些。就意味着Student、Worker都可以用Person的比较器
class Xxx implements Comparator<? super Student> {}3、何时使用下限？
通常对集合中的元素进行取出操作时，可以使用下限。存什么类型，可以用 这个类型或这个类型的父类型 来接收 -- 较为少用
eg：比较器就是取集合中的元素，用一个父类型来接收，保证取出的全都可以被接收到
说明：一个容器TreeSet<Person>中既能添加Person对象，又能addAll()添加子类对象，意味着有Person又有Student、Worker。想统一对这些对象进行排序，排的时候要把它们取出来比较，拿什么来接收？此时应该拿Person来接收。意味着如果存储的全部都是Student、Worker，也都能用Person接收。只要用的是Person的方法来进行比较，全用此方法即可
五、通配符的体现
1、boolean containsAll(Collection<?> c)：contains()方法的原理是在用equals()做判断，而equals()方法任何对象都具备，且其参数是Object
原因：
（1）任何对象都有equals()方法
（2）equals()可以接收任意对象（比的是地址值）
ArrayList<Person> list1 = new ArrayList<Person>();
list1.addAll(new Person("zhangsan"));
ArrayList<Person> list2 = new ArrayList<Person>();
list2.addAll(new Person("xiaoqi"));
ArrayList<String> list3 = new ArrayList<String>();
list3.add("abc");
//不报错。因为 boolean containsAll(Collection<?> c)
list1.containsAll(list2);
list1.containsAll(list3);2、何时使用<?> ？
（1）只要里面用的全都是Object的方法，就用<?>
（2）有的方法返回一个集合，但不知道返回的集合是什么类型，用<?> （返回<?>就用<?>接收即可）
六、集合查阅的技巧
1、需要唯一吗？
需要：Set
需要指定顺序吗？
需要：TreeSet
不需要：HashSet
不需要，但想要有一个和存储一致的顺序（有序）：LinkedHashSet
不需要：List
需要频繁增删吗?
需要：LinkedList
不需要：ArrayList
需要同步（效率低）吗？
需要：Vector
2、怎样记住每一个容器的结构和所属体系呢？
看名字
（1）后缀名就是该集合所属的体系（通过体系可以判断其特点）
|-- List ：有角标、有序、可重复
|-- ArrayList
|-- LinkedList
|-- Set ：元素唯一，无序
|-- HashSet
|-- TreeSet
（2） 前缀名就是该集合的数据结构
看到 array：就要想到数组，就要想到查询快（有角标）
看到 link：就要想到链表，就要想到增删快，就要想到 add、get、remove + first/last 的方法
看到 hash：就要想到哈希表，就要想到唯一性，就要想到元素需要覆盖hashCode()方法和equals()方法
看到 tree：就要想到二叉树，就要想到排序，就要想到两个接口Comparable、Comparator
注：通常，这些常用的集合容器都是不同步的。Vector是同步的
3、看到排序，想到元素需要具备比较性，就要使用Comparable或Comparator