Java集合——泛型

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

一、泛型类

创建泛型类：

package List;


/**
 * 泛型类
 * 语法，类名<T>
 * T是类型占位符，表示一种引用类型，如果编写多个，使用逗号隔开
 */

public class MyGeneric<T> {
    //使用泛型T
    //1、创建变量
    T t;

    //2、T作为方法的参数
    public void show(T t){
        System.out.println(t);
    }

    //3、泛型作为方法的返回值
    public T getT(){
        return t;
    }
}

使用泛型类：

package List;

public class TestGeneric {
    public static void main(String[] args) {
        //使用泛型类创建对象
        //注意：1、泛型只能是引用类型  2、不同类型的泛型对象，不能相互赋值

        // T为 String 类型
        MyGeneric<String> myGeneric = new MyGeneric<String>();
        myGeneric.t = "hello";
        myGeneric.show("大家好"); //大家好
        String string = myGeneric.getT();

        // T为 Integer 类型
        MyGeneric<Integer> myGeneric2 = new MyGeneric<Integer>();
        myGeneric2.t = 2;
        myGeneric2.show(100); // 100
        Integer integer = myGeneric2.getT();

    }
}

二、泛型接口

创建泛型接口：

package List;

/**
 * 泛型接口
 * 语法：接口名<T>
 * 注意：不能创建泛型静态常量
 */

public interface MyInterface<T> {
    String name = "张三";

    T server(T t);
}

1、第一种实现类：在实现接口时就定义了实现的类型

package List;

public class MyInterfaceImpl implements MyInterface<String>{

    @Override
    public String server(String s) {
        System.out.println(s);
        return s;
    }
}

使用这种实现类：

MyInterfaceImpl impl1 = new MyInterfaceImpl();
impl1.server("接口实现类输出");

2、第二种实现类：实现类仍为泛型

package List;

/**
 * 实现接口时仍不确定 T 的具体类型，实现类仍是泛型类
 * @param <T>
 */
public class MyInterfaceImpl2<T> implements MyInterface<T>{

    @Override
    public T server(T t) {
        System.out.println(t);
        return t;
    }
}

使用这种实现类：

MyInterfaceImpl2<Integer> impl2 = new MyInterfaceImpl2<Integer>();
impl2.server(2);

三、泛型方法

创建泛型方法：

package List;

/**
 * 泛型方法
 * 语法：<T> 返回值类型
 */

public class MyGenericMethod {

    //泛型方法
    public <T> T show(T t){
        System.out.println("泛型方法"+ t);
        return t;
    }
}

泛型方法使用：

MyGenericMethod myGenericMethod = new MyGenericMethod();
 //里面传的这个值不用定义类型，直接传值即可，代码会自动判断T的类型
 myGenericMethod.show("中国加油");
 myGenericMethod.show(10000);
 myGenericMethod.show(13.1415);

四、泛型集合

概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致

特点：

• 编译时即可检查，而非运行时抛出异常
• 访问时，不必类型转换（拆箱）
• 不同泛型之间应用不能相互赋值，泛型不存在多态

（一）创建一个普通的集合

public static void main(String[] args) {
        ArrayList arrayList = new ArrayList<>();
        arrayList.add("aaa");
        arrayList.add("bbb");
        arrayList.add(100);
        arrayList.add(2);

        for (Object object:arrayList) {
            String str = (String) object;
            System.out.println(str);
        }
    }

我们可以看到，arrayList中的元素默认为object，它们有integer类型，也有string类型，我们试图将它们强制转换为string类型，那么就会出现错误：( Integer无法强转为string类型 )

Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
	at List.demo2.main(demo2.java:14)

（二）创建泛型集合
创建集合时，就将其定义为String类型，则集合中的元素都是String类型

public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("aaa");
        arrayList.add("bbb");

        for (String str:arrayList) {
            System.out.println(str);
        }
    }