Java中的泛型

点击上方蓝色文字，添加关注。

哈喽大家好，今天为大家分享泛型，老套路，看标题！

代码枯燥图片来解闷

（一）首先introduce一下set集合：

Set是一个接口，派生于Collection接口，无序且不能包含相同元素，包括HashSet TreeSet，第一者又包括了LinkedHashSet

特点：

1. HashSet：底层基于HashMap（底层基于哈希表+红黑树（jdk1.8之后）），线程不安全，默认大小是16，加载因子是0.75，每次扩容1倍。

2. TreeSet：底层基于TreeMap（底层基于红黑树），可用于排序，线程不安全。

（二）昨天讲过了List的遍历方式（五种），今天讲一下Set集合的遍历方式

Set set1 = new Hashset();
set.add(new Person("张三",20));
set.add(new Person("李四",23));
set.add(new Person("王五",21));
System.out.println("==========增强for循环===========");
for(Object obj:set1){
  System.out.println(((Person)obj).toString());
}
System.out.println("==========迭代器===========");
Iterator it = set1.iterator();
while(it.hasNext()){
  System.out.println(((Person)it.next()).toString());
}
System.out.println("==========转换成数组进行遍历===========");
Object[] obj = set.toArray();
for(int i=0;i<obj.length;i++){
  System.out.println(((Person)obj[i]).toString());
}

为什么不能使用普通for循环，原因是set集合没有索引概念。

（三）接下来开始泛型了

以下代码为何会有编译错误尼：
原因是泛型已经申明成String类型了，那你如果再往里面传其他类型的，岂不怪哉了。。。

List<String> list = new ArrayList<String>();
list.add(new Person("张三"，20));//编译错误
list.add("jsdf");
list.add(999);//编译错误
Iterator<String> it = list.iterator();
while(it.hasNext()){
  System.out.println(it.next());
}

通过这个例子，我们来说一下泛型的好处吧：

1. 把运行期出现的问题转到编译器去处理

2. 省去了向下转型的麻烦，提高了安全性

具体例子看下方代码，很明显，第七行不用向下转型了。

public class Entrance {
  public static void main(String[] args) {
    //set处的泛型是指装载什么类型的数据 而匿名对象的泛型是指比较什么类型的数据，二者没有关系
    Set<String> set = new TreeSet<String>(new Comparator<String>() {
      @Override
      public int compare(String o1, String o2) {
        //此处也不i用向下转型了
        return o1.length()-o2.length();
      }
    });
    set.add("jdsif");
    set.add("125");
    System.out.println(set);
    //set.add(54);编译报错
  }
}

（四）自定义泛型类：

可见，泛型类型可以随意，很方便。

注意：泛型创建的时候，可以指定泛型的具体类型，在类体中都可以使用，除了静态成员

public class Entrance {
  public static void main(String[] args) {
    Person<String> person = new Person<String>();
    String string = person.test("jdsif");
    System.out.println(string);
  }
}
class Person<T>{
  public T test(T t) {
    return t;
  }
}

public class Entrance {
  public static void main(String[] args) {
    Person<String,Integer> person = new Person<String,Integer>();
    person.test("jdsif",20);
  }
}
class Person<T,E>{
  public void  test(T t,E e) {
    System.out.println("这是T类型的"+t);
    System.out.println("这是E类型的"+e);
  }
}

public class Entrance {
  public static void main(String[] args) {
    Person<String,Integer,Student> person = new Person<String,Integer,Student>();
    person.test("jdsif",20,new Student<String>("李四同学"));
    new Student<String>("张三").test("张三test");;
  }
}
class Person<T,E,V>{
  public void  test(T t,E e,V v) {
    System.out.println("这是T类型的"+t);
    System.out.println("这是E类型的"+e);
    System.out.println("这是V类型的"+v);
  }
}
class Student<E>{
  private String nameString;
  public Student(String nameString) {
    this.nameString = nameString;
  }
  public void test(E e) {
    System.out.println("Student里面的e类型"+e);
  }
  @Override
  public String toString() {
    return "Student [nameString=" + nameString + "]";
  }
}

代码枯燥图片解闷

（五）自定义泛型方法：

注意泛型方法的书写方式

public class Entrance {
  public static void main(String[] args) {
    Person person = new Person();
    person.test("xxxx");
    person.test(20, "java", 3.14);
  }
}
class Person{
  public <T,E,V> void test(T t,E e,V v) {
    System.out.println("这是T类型的"+t);
    System.out.println("这是E类型的"+e);
    System.out.println("这是V类型的"+v);
  }
  public <T> T test(T t) {
    return t;
  }
}

（六）泛型接口：

class Person implements A<String,Integer,Double>{


  @Override
  public String test(Integer e, Double v) {
    // TODO Auto-generated method stub
    return null;
  }
}
interface A<T,E,V>{
  public T test(E e,V v);
}

（七）泛型限定：

1. 泛型限定上限：<? extends T>,也就是只能传T类型或者T类型的子类型
   

public class Entrance {
  public static void main(String[] args) {
    List<Person> list = new ArrayList<Person>();
    List<Student> list1 = new ArrayList<Student>();
    test(list);
    test(list1);//编译错误
  }
  public static void test(List<Person> list) {
    
  }
}
class Person{
  
}
class Student{
  
}

上述代码为什么会编译错误，原因是已经设定了只能传递装有Person类型的实参了。看下面代码。

public class Entrance {
  public static void main(String[] args) {
    List<Person> list = new ArrayList<Person>();
    List<Student> list1 = new ArrayList<Student>();
    test(list);
    test(list1);//编译错误
  }
  public static void test(List<? extends Person> list) {
    
  }
}
class Person{
  
}
class Student extends Person{
  
}

现在用了限定就不会报错了，哈哈。

    2. 泛型限定下限：<? super T>,也就是只能传T类型或者T类型的父类型

public class Entrance {
  public static void main(String[] args) {
    List<Person> list = new ArrayList<Person>();
    List<Student> list1 = new ArrayList<Student>();
    test(list);
    test(list1);//编译错误
  }
  public static void test(List<? super Student> list) {
    
  }
}
class Person{
  
}
class Student extends Person{
  
}

今天的分享结束了，完美的一塌糊涂，泛型在应用中也是相当广泛的。

站在风口浪尖，一首野狼disco送给大家。

和小哥一起，右下方点赞点在看