Java泛型详解&泛型的优点、方法及相关细节

Java泛型详解

1. 泛型

Java泛型是J2 SE1.5中引入的一个新特性，其本质是参数化类型，也就是说所操作的数据类型被指定为一个参数（type parameter）这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。

2. 泛型的优点

2.1 类型安全

泛型的主要目标是提高Java程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在非常高的层次上验证类型假设。通过在变量声明中捕获这一附加的类型信息，泛型允许编译器实施这些附加的类型约束。类型错误就可以在编译时被捕获了，而不是在运行时当作ClassCastException展示出来。将类型检查从运行时挪到编译时有助于Java开发人员更早、更容易地找到错误，并可提高程序的可靠性。

//没有泛型的情况
public static void main(String[] args) {
    
    
    ArrayList list = new ArrayList<>();
    list.add("11");
    list.add(123);//编译正常
}

//有泛型的情况
public static void main(String[] args) {
    
    
    List<String> list = new ArrayList<>();
    list.add("11");
    list.add(123);//编译报错
}

2.2 消除强制类型转换

泛型的一个附带好处是，消除源代码中的许多强制类型转换

//没有泛型的代码段需要强制转换
public static void main(String[] args) {
    
    
    List list = new ArrayList();
    list.add(123);
    Integer integer = (Integer) list.get(0);
}

//有泛型的代码段不需要强制转换
public static void main(String[] args) {
    
    
    List<Integer> list = new ArrayList<Integer>();
    list.add(1);
    int s = list.get(0);
}

2.3 更高的运行效率

避免了不必要的装箱、拆箱操作，提高程序的性能。在非泛型编程中，将简单类型作为Object传递时会引起Boxing（装箱）和Unboxing（拆箱）操作，这两个过程都是具有很大开销的。引入泛型后，就不必进行Boxing和Unboxing操作了，所以运行效率相对较高，特别在对集合操作非常频繁的系统中，这个特点带来的性能提升更加明显。

//没有使用泛型
public static void main(String[] args) {
    
    
    //由于是object类型，会自动进行装箱操作。
    Object a = 1;
    //强制转换，拆箱操作。这样一去一来，当次数多了以后会影响程序的运行效率。
    int b = (int) a;
}

//使用了泛型

潜在的性能收益

提高了代码的重用性，泛型的程序设计，意味着编写的代码可以被很多不同类型的对象所重用

3. 泛型的使用

泛型的三种使用方式：泛型类，泛型方法，泛型接口

泛型只在编译阶段有效

3.1 泛型类

泛型类型必须是引用类型（非基本数据类型）。泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map。

//格式
public class 类名 <泛型类型1,...> {
    
    
    
}

public static void main(String[] args) {
    
    
    //泛型类
    Generics<String> name = new Generics<>("泛型");
    System.out.println(name.getValue());


    Generics<Integer> number = new Generics<>(1111);
    System.out.println(number.getValue());

}

public static class Generics<T> {
    
    
    private T value;


    public Generics(T value) {
    
    
        this.value = value;
    }

    public T getValue() {
    
    
        return value;
    }

    public void setValue(T value) {
    
    
        this.value = value;
    }
}

//结果
泛型
1111

3.2 泛型方法

泛型方法，是在调用方法的时候指明泛型的具体类型。

//格式
public <泛型类型> 返回类型 方法名（泛型类型 变量名） {
    
    
    
}

public static void main(String[] args) {
    
    

        Test d = new Test();
        String str = d.function("泛型");
        int i = d.function(1);
        System.out.println(str);
        System.out.println(i);


}

static class Test {
    
    
    public <T> T function(T t) {
    
    
        return t;
    }
}

//结果
泛型
1

3.3 泛型类接口

? 泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中。方法声明中定义的形参只能在该方法里使用，而接口、类声明中定义的类型形参则可以在整个接口、类中使用。当调用fun()方法时，根据传入的实际对象，编译器就会判断出类型形参T所代表的实际类型，使用泛型的时候，前后定义的泛型类型必须保持一致，否则会出现编译异常

//格式
public interface 接口名<泛型类型> {
    
    
    
}

public static void main(String[] args) {
    
    
        GenericsInterface getString = new getStringImpl();
    	getString.get("111");
        GenericsInterface getInteger = new getIntegerImpl();
    	getInteger.get(123);

    }

public static class getStringImpl implements GenericsInterface<String> {
    
    
    @Override
    public void get(String value) {
    
    
        System.out.println(value);
    }
}

public static class getIntegerImpl implements GenericsInterface<Integer> {
    
    
    @Override
    public void get(Integer value) {
    
    
        System.out.println(value);
    }
}

public interface GenericsInterface<T> {
    
    
    void get(T value);
}

//结果
111
123

使用注意

• 泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。
• 泛型的类型参数可以有多个。
• 不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的，编译时会出错。
• 不能创建一个确切的泛型类型的数组。

4. 泛型通配符

4.1 常用的通配符

E： Element (在集合中使用，因为集合中存放的是元素)
T：Type（Java 类）
K： Key（键）
V： Value（值）
N： Number（数值类型）
？： 表示不确定的java类型

4.2 通配符上界

<？ extends T>，在类型参数中使用 extends 表示这个泛型中的参数必须是 E 或者 E 的子类

使用固定上边界的通配符的泛型, 就能够接受指定类及其子类类型的数据。
要声明使用该类通配符, 采用<? extends E>的形式, 这里的E就是该泛型的上边界。
注. 这里虽然用的是extends关键字, 却不仅限于继承了父类E的子类, 也可以代指显现了接口E的类

public static void main(String[] args) {
    
    
        List<Father> listF = new ArrayList<>();
        List<Son> listS = new ArrayList<>();
        List<Daughter> listD = new ArrayList<>();
        testExtend(listF);
        testExtend(listS);
        testExtend(listD);

}

private static <T> void testExtend(List<? extends Father> list) {
    
    }

static class Father {
    
    }

static class Daughter extends Father {
    
    }

static class Son extends Father {
    
    }

4.3 通配符下界

<？ super T>，在类型参数中使用 super 表示这个泛型中的参数必须是 E 或者 E 的父类。

使用固定下边界的通配符的泛型, 就能够接受指定类及其父类类型的数据.。
要声明使用该类通配符, 采用<? super E>的形式, 这里的E就是该泛型的下边界.。
注. 你可以为一个泛型指定上边界或下边界, 但是不能同时指定上下边界。

public static void main(String[] args) {
    
    
        List<Father> listF = new ArrayList<>();
        List<Son> listS = new ArrayList<>();
        List<Daughter> listD = new ArrayList<>();
        testSuper(listF);
        testSuper(listS);
        testSuper(listD);

    }

    private static void testSuper(List<? super Son> list){
    
    } {
    
    }

    static class Father {
    
     }

    static class Daughter extends Father {
    
    }

    static class Son extends Father {
    
    }
	 List<? super Son> list 接受的类型只能是 Son 或者是 Son 的父类，而 Father 和 GrandFather 又都是 Son 的父类，所以以上程序是没有任何问题的，但是如果再来一个类是 Son 的子类（如果不是和 Son 有关联的类那更不行了）

4.4 无界通配符

<?>，即类型参数可以是任何类型

无边界的通配符的主要作用就是让泛型能够接受未知类型的数据

public static void main(String[] args) {
    
    
    List<Integer> arrays = Arrays.asList(1, 1, 1);
    List<String> arrayString = Arrays.asList("1", "1", "1");
    printList(arrays);
    printList(arrayString);

}

public static void printList(List<?> list) {
    
    
    for (Object elem : list) {
    
    
        System.out.print(elem + "");
    }
    System.out.println();
}

//结果
111
111

5.类型擦除

Java的泛型是伪泛型，为什么说Java的泛型是伪泛型呢？因为在编译期间，所有的泛型信息都会被擦除掉，我们常称为泛型擦除。

@Test
public void test() {
    
    
    List<String> stringList = new ArrayList<String>();
    stringList.add("泛型");
    List<Integer> integerList = new ArrayList<Integer>();
    integerList.add(1);
    System.out.println(stringList.getClass() == integerList.getClass());
}

//结果
true

定义了两个List，不过一个是List泛型类型，只能存储字符串。一个是List泛型类型，只能存储整型。最后，我们通过stringList对象和integerList对象的getClass方法获取它们的类的信息，最后发现结果为true。说明泛型类型String和Integer都被擦除掉了，只剩下了原始类型。

泛型的优点、方法及相关细节

泛型—— 一种可以接收数据类型的数据类型。

一、泛型的引入

我们都知道，继承是面向对象的三大特性之一，比如在我们向集合中添加元素的过程中add()方法里填入的是Object类，而Object又是所有类的父类，这就产生了一个问题——添加的类型无法做到统一 由此就可能产生在遍历集合取出元素时类型不统一而报错问题。

例如：我向一个ArrayList集合中添加Person类的对象，但是不小心手贱添加了一个Boy类的对象，这就会导致如下结果

二、使用泛型的好处

1.提升了程序的健壮性和规范性

针对上述问题，当我们采用泛型就会显得非常简单，只需要在编译类型后利用泛型指定一个特定类型，编译器就会自动检测出不符合规范的类并抛出错误提示

3.减少了类型转换的次数,提高效率

• 当不使用泛型时：

4.在类声明时通过一个标识可以表示属性类型、方法的返回值类型、参数类型

class Person<E> {
    
     
    E s;   //可以是属性类型
    public Person(E s) {
    
      //可以是参数类型
        this.s = s;
    }
    public E f() {
    
     //可以是返回类型
        return s;
    }
    public void show() {
    
    
        System.out.println(s.getClass());  //显示S的运行类型
    }
}

可以这样理解：上述的class Person< E >中的“E”相当于这里的E是一个躯壳 占位用的 以后定义的时候程序员可以自己去自定义

就像这样

public static void main(String[] args) {
    
    
    Person<String> person1 = new Person<String>("xxxx");// E->String
    person.show(); 
    Person<Integer> person2 = new Person<Integer>(123); // E->Integer
    person.show();
}
运行结果：
class java.lang.String
class java.lang.Integer

三、泛型常见用法

1.定义泛型接口

曾经写接口的时候都没有定义泛型，它默认的就是Object类，其实这样写是不规范的！

如果说接口的存在是一种规范，那泛型接口就是规范中的规范

interface Im<U,R>{
    
    
    void hi(R r);
    void hello(R r1,R r2,U u1,U u2);
    default R method(U u){
    
    
        return null;
    }
}

在上述的泛型接口中已经规定传入其中的必须是U，R类的对象，那么当我们传入其他类的对象时就会报错，如图：

2.定义泛型集合

1.使用泛型方式给HashSet中放入三个学生对象，并输出对象信息

HashSet<Student> students = new HashSet<Student>();
 students.add(new Student("懒羊羊",21));
 students.add(new Student("喜羊羊",41));
 students.add(new Student("美羊羊",13));
 for (Student student :students) {
    
    
     System.out.println(student);
 }

上述的 泛型中Student的是我事先定义好的一个类，把它放到其中作为泛型来约束传入的对象，以及在遍历时减少转型的次数提高效率

2.使用泛型方式给HashMap中放入三个学生对象，并输出对象信息

HashMap<String, Student> hm = new HashMap<String, Student>();
// K-> String  V->Student与下面的对应
hm.put("001",new Student("喜羊羊",21));
hm.put("002",new Student("懒羊羊",32));
hm.put("003",new Student("美羊羊",43));
Set<Map.Entry<String,Student>> ek=hm.entrySet();
Iterator<Map.Entry<String, Student>> iterator = ek.iterator();//取出迭代器
while (iterator.hasNext()) {
    
    
    Map.Entry<String, Student> next =  iterator.next();
    System.out.println(next.getKey()+" - "+next.getValue());
}

HashMap是一个双列集合，以[K-V]的方式存储对象，因此在使用泛型时要向其中传入两个类型

我们都知道使用迭代器遍历HashMap时要先通过entrySet()取出键值对，然后通过转型得到对应的类来得到对象信息。而在使用泛型定义[K-V]就规定了取出的键值对的类型，所以就省去了转型这一步骤，同样也使程序变得简单，高效

四、泛型使用细节

1.<>中类型规范

在给泛型指定具体类型后，可以传入该类型或者其子类类型

P<A> ap = new P<A>(new A());
P<A> ap1 = new P<A>(new B()); //A的子类
class A {
    
    }
class B extends A{
    
    }

3.简写形式

P<A> ap = new P(new A());

五、自定义泛型

1.自定义方法使用类声明的泛型

在形参列表中传入的数据类型与泛型不一致时会报错，体现规范性

public static void main(String[] args) {
    
    
    U<String, Double, Integer> u = new U<>();
    u.hi("hello", 1.0);  //X->String Y->Double
}
class U<X, Y, Z> {
    
    
    public void hi(X x, Y y) {
    
    } //使用类声明的泛型
}

2.自定义泛型方法

public static void main(String[] args) {
    
    
    U<String, Double, Integer> u = new U<>();
    u.m1("xx",22);
    //当调用方法时，传入参数编译器会自己确定类型 会自动装箱
}
class U<X, Y, Z> {
    
    
    public <X,Y> void m1(X x,Y y){
    
    } //自定义泛型方法
}

这里的自动装箱很有意思，他是在三个类型中自动匹配当前输入的数据类型，也不用考虑顺序问题，如图所示

①泛型数组不能初始化，因为数组在 new 不能确定A 的类型，就无法在内存开空间

错误写法: A[] a=new A[];

②静态方法不能使用类定义的泛型