不多说，直接上干货！

　　先来看个泛型概念提出的背景的例子。

　GenericDemo.java

package zhouls.bigdata.DataFeatureSelection;import java.util.ArrayList;
import java.util.Iterator;public class GenericDemo {    /**
     * @param args
     */
    public static void main(String[] args) {
        ArrayList al = new ArrayList();        al.add("abc");//public boolean add(Object obj)
        al.add("hahah");
        al.add();//al.add(new Integer(4));        Iterator it = al.iterator();
        while(it.hasNext()){
            String str = (String)it.next();//1处
            System.out.println(str);
        }
    }
}

　　输出

Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
    at zhouls.bigdata.DataFeatureSelection.GenericDemo.main(GenericDemo.java:)
abc
hahah

　　以上是运行时期出现问题了。

　　定义了一个List类型的集合，先向其中加入了两个字符串类型的值，随后加入一个Integer类型的值。这是完全允许的，因为此时list默认的类型为Object类型。在之后的循环中，由于忘记了之前在list中也加入了Integer类型的值或其他编码原因，很容易出现类似于//1中的错误。因为编译阶段正常，而运行时会出现“java.lang.ClassCastException”异常。因此，导致此类错误编码过程中不易发现。

 　　在如上的编码过程中，我们发现主要存在两个问题：

　　1.当我们将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，改对象的编译类型变成了Object类型，但其运行时类型任然为其本身类型。

　　2.因此，//1处取出集合元素时需要人为的强制类型转化到具体的目标类型，且很容易出现“java.lang.ClassCastException”异常。

　　那么有没有什么办法可以使集合能够记住集合内元素各类型，且能够达到只要编译时不出现问题，运行时就不会出现“java.lang.ClassCastException”异常呢？答案就是使用泛型。

　　　　再次修改，GenericDemo.java

　　这就是，将运行时期的问题ClassCastException转到了编译时期。

　　再次修改，GenericDemo.java

package zhouls.bigdata.DataFeatureSelection;import java.util.ArrayList;
import java.util.Iterator;public class GenericDemo {
    /**
     * @param args
     */
    public static void main(String[] args) {        ArrayList<String> al = new ArrayList<String>();        al.add("abc");//public boolean add(Object obj)
        al.add("hahah");
//      al.add(4);//al.add(new Integer(4));//1处        Iterator<String> it = al.iterator();
        while(it.hasNext()){
            String str = it.next();//2处
            System.out.println(str);
        }
    }
}

　　采用泛型写法后，在//1处想加入一个Integer类型的对象时会出现编译错误，通过List<String>，直接限定了list集合中只能含有String类型的元素，从而在//2处无须进行强制类型转换，因为此时，集合能够记住元素的类型信息，编译器已经能够确认它是String类型了。

　　结合上面的泛型定义，我们知道在List<String>中，String是类型实参，也就是说，相应的List接口中肯定含有类型形参。且get()方法的返回结果也直接是此形参类型（也就是对应的传入的类型实参）。

什么是泛型？

　　泛型：jdk1.5出现的安全机制。

　　我们在编写程序时，经常遇到两个模块的功能非常相似，只是一个是处理int型数据，另一个是处理String类型数据，或者其它自定义类型数据，但是我们没有办法，只能分别写多个方法处理每种数据类型，因为方法的参数类型不同。有没有一种办法，在方法中传入通用的数据类型，这样不就可以合并代码了吗？泛型的出现就是专门解决这个问题的。

使用泛型的好处：
　　好处：
　　1、将运行时期的问题ClassCastException转到了编译时期。
　　2、避免了强制转换的麻烦。

<>什么时候用？

　　当操作的引用数据类型不确定的时候。就使用<>。将要操作的引用数据类型传入即可.
　　其实<>就是一个用于接收具体引用数据类型的参数范围。

　　里面是引用类型，要么放类名，要么放接口名，要么放数组名。

　　在程序中，只要用到了带有<>的类或者接口，就要明确传入的具体引用数据类型 。泛型技术是给编译器使用的技术,用于编译时期。确保了类型的安全。

运行时，会将泛型去掉，生成的class文件中是不带泛型的,这个称为泛型的擦除。

　　为什么擦除呢？因为为了兼容运行的类加载器。

　　泛型的补偿：在运行时，通过获取元素的类型进行转换动作。不用使用者在强制转换了。

泛型在集合中的应用

　　我这里仅仅以集合中的TreeSet为例，

　　更多集合，请见

牛客网Java刷题知识点之Java 集合框架的构成、集合框架中的迭代器Iterator、集合框架中的集合接口Collection、集合框架中的Map集合

 GenericDemo.java

package zhouls.bigdata.DataFeatureSelection;import java.util.Iterator;
import java.util.TreeSet;import zhouls.bigdata.DataFeatureSelection.Person;
import zhouls.bigdata.DataFeatureSelection.ComparatorByName;public class GenericDemo {    /**
     * @param args
     */
    public static void main(String[] args) {    TreeSet<Person> ts = new TreeSet<Person>(new ComparatorByName());
        ts.add(new Person("lisi8",));
        ts.add(new Person("lisi3",));
        ts.add(new Person("lisi",));
        ts.add(new Person("lis0",));        Iterator<Person> it = ts.iterator();        while(it.hasNext()){
            Person p = it.next();
            System.out.println(p.getName()+":"+p.getAge());
        }
    }}

　　因为TreeSet是需要是二叉树，需要进行比较排序。

Person.java

package zhouls.bigdata.DataFeatureSelection;public class Person implements Comparable<Person> {    private String name;
    private int age;    public Person() {
        super();
    }    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }    public int compareTo(Person p){
//        Person p = (Person)obj;
        int temp = this.age - p.age;
        return temp==?this.name.compareTo(p.name):temp;
    }    @Override
    public int hashCode() {
        final int prime = ;
        int result = ;
        result = prime * result + age;
        result = prime * result + ((name == null) ?  : name.hashCode());
        return result;
    }     @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }    @Override
    public String toString() {        return "Person:"+getName()+":"+getAge();
    }
}

 ComparatorByName.java

package zhouls.bigdata.DataFeatureSelection;import java.util.Comparator;import zhouls.bigdata.DataFeatureSelection.Person;public class ComparatorByName implements Comparator<Person> {
    public int compare(Person o1, Person o2) {
        int temp = o1.getName().compareTo(o2.getName());
        return temp==0? o1.getAge()-o2.getAge(): temp;
    }
}

　什么是泛型类？什么时候用泛型类？泛型类？

　　在jdk1.5后，使用泛型来接收类中要操作的引用数据类型。
　　泛型类。什么时候用？当类中的操作的引用数据类型不确定的时候，就使用泛型来表示。

 Tool.java

package zhouls.bigdata.DataFeatureSelection;/*
public class Tool {    private Object object;    public Object getObject() {
        return object;
    }    public void setObject(Object object) {
        this.object = object;
    }}*/
//在jdk1.5后，使用泛型来接收类中要操作的引用数据类型。
//泛型类。什么时候用？当类中的操作的引用数据类型不确定的时候，就使用泛型来表示。
public class Tool<QQ>{
    private QQ q;    public QQ getObject(){
        return q;
    }    public void setObject(QQ object){
        this.q = object;
    }    /**
     * 将泛型定义在方法上。
     * @param str
     */
    public <W> void show(W str){
        System.out.println("show : "+str.toString());
    }
    public void print(QQ str){
        System.out.println("print : "+str);
    }    /**
     * 当方法静态时，不能访问类上定义的泛型。如果静态方法使用泛型，只能将泛型定义在方法上。
     * @param obj
     */
    public static <Y> void method(Y obj){
        System.out.println("method:"+obj);
    }
}

　　GenericDefineDemo.java

package zhouls.bigdata.DataFeatureSelection;import zhouls.bigdata.DataFeatureSelection.Student;
import zhouls.bigdata.DataFeatureSelection.Worker;public class GenericDefineDemo{
    /**
     * @param args
     */
    public static void main(String[] args){
        Tool<String> tool = new Tool<String>();
        tool.show(new Integer());//show : 4
        tool.show("abc");//show : abc
        tool.print("hahah");//print : hahah
//        tool.print(new Integer(8));//不能
        Tool.method("haha");//method:haha
        Tool.method(new Integer());//method:9
    }}

 Student.java

package zhouls.bigdata.DataFeatureSelection;public class Student extends Person{    public Student(){
        super();    }    public Student(String name, int age){
        super(name, age);    }    @Override
    public String toString(){
        return "Student:"+getName()+":"+getAge();
    }
}

 Worker.java

package zhouls.bigdata.DataFeatureSelection;public class Worker extends Person{    public Worker(){
        super();
    }    public Worker(String name, int age){
        super(name, age);
    }    @Override
    public String toString(){
        return "Worker:"+getName()+":"+getAge();
    }
}

Person.java

package zhouls.bigdata.DataFeatureSelection;public class Person implements Comparable<Person> {
    private String name;
    private int age;    public Person() {
        super();    }    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }    public int compareTo(Person p){
//        Person p = (Person)obj;
        int temp = this.age - p.age;
        return temp==?this.name.compareTo(p.name):temp;
    }    @Override
    public int hashCode() {
        final int prime = ;
        int result = ;
        result = prime * result + age;
        result = prime * result + ((name == null) ?  : name.hashCode());
        return result;
    }    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }    @Override
    public String toString() {        return "Person:"+getName()+":"+getAge();
    }
}

泛型接口

 GenericDefineDemo.java

package zhouls.bigdata.DataFeatureSelection;public class GenericDefineDemo {
    /**
     * @param args
     */
    public static void main(String[] args) {
        InterImpl in = new InterImpl();
        in.show("abc");        InterImpl2<Integer> in2 = new InterImpl2<Integer>();
        in2.show();
    }
}//泛型接口，将泛型定义在接口上。
    interface Inter<T>{
        public void show(T t);
    }    class InterImpl2<Q> implements Inter<Q>{
        public void show(Q q){
            System.out.println("show :"+q);
        }
    }    class InterImpl implements Inter<String>{
        public void show(String str){
            System.out.println("show :"+str);
        }
    }    

泛型限定上限

 GenericAdvanceDemo.java

package zhouls.bigdata.DataFeatureSelection;import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;public class GenericAdvanceDemo {
    /**
     * @param args
     */
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<String>();
        al.add("abc");
        al.add("hehe");        ArrayList<Integer> al2 = new ArrayList<Integer>();
        al2.add();
        al2.add();
        printCollection(al);
        printCollection(al2);
    }    /**
     * 迭代并打印集合中元素。
     * @param al
     */
    public static void printCollection(Collection<?> al) {
        Iterator<?> it = al.iterator();
        while(it.hasNext()){
            System.out.println(it.next().toString());
        }
    }
}

泛型限定下限

GenericAdvanceDemo.java

package zhouls.bigdata.DataFeatureSelection;import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;import zhouls.bigdata.DataFeatureSelection.Person;
import zhouls.bigdata.DataFeatureSelection.Student;
import zhouls.bigdata.DataFeatureSelection.Worker;public class GenericAdvanceDemo {
    /**
     * @param args
     */
    public static void main(String[] args) {
        ArrayList<Person> al = new ArrayList<Person>();
        al.add(new Person("abc",));
        al.add(new Person("abc4",));        ArrayList<Student> al2 = new ArrayList<Student>();
        al2.add(new Student("stu1",));
        al2.add(new Student("stu2",));
        ArrayList<String> al3 = new ArrayList<String>();        al3.add("stu3331");
        al3.add("stu33332");        printCollection(al2);
        printCollection(al);
    }    /**
     * 迭代并打印集合中元素。
     *
     * 可以对类型进行限定：
     * ? extends E:接收E类型或者E的子类型对象。上限！
     *
     * ? super E ：接收E类型或者E的父类型。下限！
     * @param al
     */
    /*public static void printCollection(Collection<? extends Person> al) {//Collection<Dog> al = new ArrayList<Dog>()
        Iterator<? extends Person> it = al.iterator();        while(it.hasNext()){
//            T str = it.next();
//            System.out.println(str);
//            System.out.println(it.next().toString());
            Person p = it.next();            System.out.println(p.getName()+":"+p.getAge());
        }    }*/    public static void printCollection(Collection<? super Student> al){
        Iterator<? super Student> it = al.iterator();
        while(it.hasNext()){            System.out.println(it.next());
        }
    }
}

 什么时候使用上限？

 GenericAdvanceDemo.java

package zhouls.bigdata.DataFeatureSelection;import java.util.ArrayList;
import zhouls.bigdata.DataFeatureSelection.Person;
import zhouls.bigdata.DataFeatureSelection.Student;
import zhouls.bigdata.DataFeatureSelection.Worker;public class GenericAdvanceDemo{
    /**
     * @param args
     */
    public static void main(String[] args) {
        ArrayList<Person> al1 = new ArrayList<Person>();
        al1.add(new Person("abc",));
        al1.add(new Person("abc4",));        ArrayList<Student> al2 = new ArrayList<Student>();
        al2.add(new Student("stu1",));
        al2.add(new Student("stu2",));        ArrayList<Worker> al3 = new ArrayList<Worker>();
        al3.add(new Worker("stu1",));
        al3.add(new Worker("stu2",));        ArrayList<String> al4 = new ArrayList<String>();
        al4.add("abcdeef");
//        al1.addAll(al4);//错误，类型不匹配。        al1.addAll(al2);
        al1.addAll(al3);
        System.out.println(al1.size());
    }
}/*
 * 一般在存储元素的时候都是用上限，因为这样取出都是按照上限类型来运算的。不会出现类型安全隐患。
 */
class MyCollection<E>{
    public void add(E e){    }
    public void addAll(MyCollection<? extends E> e){
    }
}

什么时候使用下限？

 GenericAdvanceDemo.java

package zhouls.bigdata.DataFeatureSelection;import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;import zhouls.bigdata.DataFeatureSelection.Person;
import zhouls.bigdata.DataFeatureSelection.Student;
import zhouls.bigdata.DataFeatureSelection.Worker;public class GenericAdvanceDemo {
    /**
     * @param args
     */
    public static void main(String[] args) {
        TreeSet<Person> al1 = new TreeSet<Person>(new CompByName());
        al1.add(new Person("abc4",));
        al1.add(new Person("abc1",));
        al1.add(new Person("abc2",));        TreeSet<Student> al2 = new TreeSet<Student>(new CompByName());
        al2.add(new Student("stu1",));
        al2.add(new Student("stu7",));
        al2.add(new Student("stu2",));        TreeSet<Worker> al3 = new TreeSet<Worker>();
        al3.add(new Worker("stu1",));
        al3.add(new Worker("stu2",));        TreeSet<String> al4 = new TreeSet<String>();
        al4.add("abcdeef");
//        al1.addAll(al4);//错误，类型不匹配。
//        al1.addAll(al2);
//        al1.addAll(al3);
//        System.out.println(al1.size());
        Iterator<Student> it = al2.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}/*
 * class TreeSet<Worker>
 * {
 *         Tree(Comparator<? super Worker> comp);
 * }
 * 什么时候用下限呢？通常对集合中的元素进行取出操作时，可以是用下限。
 */class CompByName implements Comparator<Person>{
    public int compare(Person o1, Person o2) {
        int temp = o1.getName().compareTo(o2.getName());
        return temp==? o1.getAge()-o2.getAge():temp;
    }
}class CompByStuName implements Comparator<Student>{
    public int compare(Student o1, Student o2) {
        int temp = o1.getName().compareTo(o2.getName());
        return temp==? o1.getAge()-o2.getAge():temp;
    }
}class CompByWorkerName implements Comparator<Worker>{
    public int compare(Worker o1, Worker o2) {
        int temp = o1.getName().compareTo(o2.getName());
        return temp==? o1.getAge()-o2.getAge():temp;
    }
}

泛型限定通配符的体现

 GenericAdvanceDemo.java

package zhouls.bigdata.DataFeatureSelection;import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;import zhouls.bigdata.DataFeatureSelection.Person;
import zhouls.bigdata.DataFeatureSelection.Student;
import zhouls.bigdata.DataFeatureSelection.Worker;public class GenericAdvanceDemo {
    /**
     * @param args
     */
    public static void main(String[] args) {
        ArrayList<Person> al1 = new ArrayList<Person>();
        al1.add(new Person("abc",));
        al1.add(new Person("abc4",));        ArrayList<Person> al2 = new ArrayList<Person>();
        al2.add(new Person("abc22222",));
        al2.add(new Person("abc42222222",));        ArrayList<String> al4 = new ArrayList<String>();
        al4.add("abcdeef");
        al4.add("abc");
        al1.containsAll(al4);
//        "abc".equals(new Person("ahahah",20));
    }
    public static void printCollection(Collection<?> al){
        Iterator<?> it = al.iterator();
        while(it.hasNext()){
            System.out.println(it.next().toString());
        }
    }
}    class MyCollection2<E>{
    public boolean containsAll(Collection<?> coll){
        return true;
    }
}

泛型的通配符：

　　? 未知类型。

泛型的限定：
　　? extends E: 接收E类型或者E的子类型对象。上限
　　一般存储对象的时候用。比如 添加元素 addAll.

　　? super E: 接收E类型或者E的父类型对象。 下限。
　　一般取出对象的时候用。比如比较器。

欢迎大家，加入我的微信公众号：大数据躺过的坑     免费给分享   

同时，大家可以关注我的个人博客：

   http://www.cnblogs.com/zlslch/   和     http://www.cnblogs.com/lchzls/ 

   详情请见：http://www.cnblogs.com/zlslch/p/7473861.html

　　人生苦短，我愿分享。本公众号将秉持活到老学到老学习无休止的交流分享开源精神，汇聚于互联网和个人学习工作的精华干货知识，一切来于互联网，反馈回互联网。
　　目前研究领域：大数据、机器学习、深度学习、人工智能、数据挖掘、数据分析。 语言涉及：Java、Scala、Python、Shell、Linux等 。同时还涉及平常所使用的手机、电脑和互联网上的使用技巧、问题和实用软件。 只要你一直关注和呆在群里，每天必须有收获

以及对应本平台的QQ群：161156071（大数据躺过的坑）