java集合之泛型

一、泛型概念

• java泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递。
• 常见形式有泛型类、泛型接口、泛型方法
• 语法
  • <T,...>T称为类型占位符，表示一种引用类型
• 好处
  • 提高代码的重用性
  • 防止类型转换异常，提高代码的安全性

二、泛型类

/**
 * 泛型类
 * 语法：类名<T>
 * T是类型点位符，表示一种引用类型，如果编写多个使用逗号隔开
 * 个人理解也可以看成是一种声明，声明类型就是Object
 */
public class GenericDemo<T> {//对泛型的声明
    //声明泛型后可以使用泛型
    //1.创建变量
    T t;
    //2.作为方法的参数
    public void show(T t){
        //不能直接创建T类型的对象，因为T类型是不确定的
        //T t1=new T();
        System.out.println(t);
    }
    //3.使用泛型作为方法的返回值
    public T getT(){
        return t;
    }
    //这里要使用泛型，需要先声明，因为静态方法不属于类，在字节码文件加载前就已经加载完成
    public static <T>void Test(T  z){
        System.out.println(z);
    }
}


//泛型类的测试类
public class TestGenericDemo {
    public static void main(String[] args) {
        /**注意：
         * 1.泛型只能是引用类型
         * 2.不同泛型类型对象之间不能相互赋值
         */
        GenericDemo<String> genericDemo1=new GenericDemo<String>();//后面的String可写可不写，jdk1.7后可以不写
        genericDemo1.t="hello";
        GenericDemo.Test(125);
        genericDemo1.show("hello,just do it");
        String t = genericDemo1.getT();
        System.out.println(t);
        GenericDemo<Integer> genericDemo2=new GenericDemo<Integer>();
        genericDemo2.t=100;
        genericDemo2.show(200);
        System.out.println(genericDemo2.getT());
        GenericDemo genericDemo3=genericDemo2;//这样赋值是可以的，因为GenericDemo3对象没有指定类型
        System.out.println(genericDemo3.t);
        //GenericDemo<Float> genericDemo4=genericDemo2;//这样是不行的，因为对象类型不同
    }
}

三、泛型接口

//泛型接口
public interface GenericAbleDemo<T>{
    String name="张三";//静态常量，默认自动添加public static final，必须赋值
    //T t=new T();//不能这么定义静态变量,因为不能确定T的类型
    T test(T t);//默认修饰符public abstract
}

//第一种泛型类的实现方式，先确定类型
public class GenericAbleDemoImp1 implements GenericAbleDemo<String>{
    @Override
    public String test(String s) {
        System.out.println(s);
        return s;
    }
}


//第二种实现方式，直接用泛型类来实现泛型接口，所以重写的方法也是泛型方法
public class GenericAbleDemoImp2<T> implements GenericAbleDemo<T> {
    @Override
    public T test(T t) {
        System.out.println(t);
        return t;
    }
}

//测试类
public class ImpTest {
    public static void main(String[] args) {
        GenericAbleDemoImp1 demoImp1=new GenericAbleDemoImp1();
        demoImp1.test("测试");
        GenericAbleDemoImp2 demoImp2=new GenericAbleDemoImp2();
        demoImp2.test("测试");
        demoImp2.test(1000);
    }
}

四、泛型方法

/***
 * 泛型方法的使用
 * 语法：<T>+返回值类型
 */
public class GenericMethodDemo {
    //泛型方法
    public <T> T show(T t){
        System.out.println("泛型方法Deme"+t);
        return t;
    }
    //静态
    public static <T> T staticShow(T t){
        System.out.println("泛型方法Deme静态"+t);
        return t;
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        GenericMethodDemo genericMethodDemo=new GenericMethodDemo();
        genericMethodDemo.show("I am a work");
        genericMethodDemo.show(100);
        genericMethodDemo.show(3.14);
        GenericMethodDemo.staticShow(3.14);
        GenericMethodDemo.staticShow(100);
        GenericMethodDemo.staticShow("I am a work");
    }
}

五、泛型集合

• 概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致。
• 特点：
  • 编译时即可检查，而非运行时抛出异常。
  • 访问时，不必类型转换（拆箱）。
  • 不同泛型之间引用不能相互赋值，泛型不存在多态。

//不用泛型的问题
import java.util.ArrayList;

public class GenericListDemo {
    public static void main(String[] args) {
        ArrayList arrayList=new ArrayList();
        arrayList.add("xxx");
        arrayList.add(10);
        for (Object o : arrayList) {
            String o1 = (String) o;
            System.out.println(o1);
            //Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
            
        }
    }
}

//使用泛型
import java.util.ArrayList;
import java.util.Iterator;

public class GenericListDemo {
    public static void main(String[] args) {
        ArrayList<String> arrayList=new ArrayList();
        arrayList.add("xxx");
        //arrayList.add(10);编译时报错
        for (String s : arrayList) {
            System.out.println(s);
        }
        Iterator<String> iterator = arrayList.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}