Java泛型

小小霸王龙！

于 2024-07-29 00:13:12 发布

阅读量232

点赞数 2

文章标签： java 开发语言

本文链接：https://blog.csdn.net/lvzihao1314/article/details/140758947

版权

泛型概述

1.1 生活中的例子

举例1：中药店，每个抽屉外面贴着标签。
举例2：超时购物加上很多瓶子，每个瓶子装的是什么，有标签。

1.2 泛型的引入

在Java中，我们在声明方法时，当在完成方法功能时如果有未知的数据需要参与，这些未知的数据需要在调用方法时才能确定，那么我们把这样的数据通过形参表示，在方法体中，用这个形参名来代替那个位置的数据，而调用者在调用时，对应的传入实参就可以了。

受以上启发，JDK1.5设计了泛型的概念，泛型即为“类型参数”，这个类型参数声明它的类，接口或方法中，代表未知的某种通用类型。

举例1：集合类在设计阶段/声明阶段不能确定这个容器到底存的是什么类型的对象，所以在JDK5.0之前只能把元素类型设计为Object，JDK5.0时引入了 “参数化类型”。

使用集合存储数据时，除了元素类型不确定，其他部分是确定的。

举例2：java.lang.Comparable接口和java.util.Comparator接口，是用于比较对象大小的接口，这两个接口只是限定了当一个对象大于另一个对象时返回正整数，小于返回负整数，等于返回0，但是并不确定是什么类型的对象比较大小。JDK5.0之前只能用Object类型表示，使用既麻烦又不安全。因此JDK5.0给它们增加了泛型。

其中 < T > 就是类型参数，也就是泛型.

所谓泛型，就是允许在定义类，接口时通过一个标识表示类中某个属性的类型或者某个方法的返回值或参数的类型，这个类型的参数将在使用时（例如，继承或实现这个接口，创建对象或调用方法时）确定（即传入实际的类型参数，也成为类型实参

2.使用泛型举例

自从JDK5.0引入泛型的概念后，对之前核心类库的API做了很大的修改，例如：JDK5.0改写了集合框架中的全部接口和类，java.lang.Comparable接口，java.util.Comparator接口，class类登，为这些接口，类增加了泛型支持，从而可以在声明变量，创建对象时传入类型实参

2.1 集合中使用泛型

2.1.1 举例

集合中没有使用泛型时

集合中使用泛型时

Java泛型可以保证如果程序在编译时没有发出警告，运行就不会产生ClassCastException异常，即，把不安全的因素在编译期间就排除了，而不是运行期，既然通过了编译，那么类型一定是符合要求的，就避免了类型转换。
同时，代码更加简洁，健壮。
把一个集合中的内容限制为一个特定的数据类型，这就是generic背后的编程思想

举例：

//泛型在List中的使用
@Test
public void test1(){
	//举例：将学生成绩保存在ArrayList中
	//标准写法：
	//ArrayList<Integer> list = new ArrayList<Integer>();
	//JDK7新特性:类型推断
	ArrayList<Integer> list = new ArrayList<>();

	list.add(56); //自动装箱
	list.add(76);
	list.add(88);
	list.add(89);
	//当添加非Integer类型数据时，编译不通过
	//list.add("Tom");编译报错

	Iterator<Integer> iterator = list.iterator();
	
	while (iterator.hasNext()){
	//不需要强转，直接可以获取添加时的元素的数据类型。
		Integer score = iterator.next();
		System.out.println(score);
	}
}

举例：

//泛型在Map中的运用
@Test
public void test2(){
	HashMap<String, Integer> map = new HashMap<>();

	map.put("Tom", 67);
	map.put("Jim", 56);
	map.put("Rose", 88);
	//编译不通过
	//map.put(67, "Jack");
	//遍历key集
	Set<String> keySet = map.keySet();
	for (String str : keySet){
		System.out.println(str);
	}
	Collection<Integer> values = map.values();
	Iterator<Integer> iterator1 = values.iterator();
	while (iterator1.hasNext()){
		Integer value = iterator.next();
		System.out.println(value);
	}
	//遍历entry集
	Set<Map, Entry<String, Integer>> entrySet = map.entrySet();
	Iterator<Map, Entry<String, Integer>> iterator2 = entrySet.iterator();
	while (iterator2.hasNext()){
		Map.Entry<String, Integer> entry = iterator2.next();
		String key = entry.getKey();
		Integer value = entry.getValue();
		System.out.println(key + " : " + value);
	}
}

2.1.2 练习

练习1：

(1) 创建一个ArrayList集合对象，并指定泛型为<Integer>。
(2) 添加5个[0, 100]以内的整数到集合中。
(3) 使用foreach遍历输出5个数
(4) 使用集合的removeIf方法删除偶数，为Predicate接口指定泛型<Integer>
(5) 再使用Iterator迭代器输出剩下的元素，为Iterator接口指定泛型<Integer>

package com.atguigu.genericclass.use;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Random;
import java.util.function.Predicate;

public class TestNumber{
	public static void main(){
		ArrayList <Integer> coll = new ArrayList<Integer>();

		Random random = new Random();
		for (int i = 0; i < 5; i ++){
			coll.add(random.nextInt(100));
		}

		System.out.println("coll中的五个数为：");

		for (Integer integer : coll){
			System.out.println(integer);
		}

		//方式1：使用集合的removeIf方法删除偶数
		coll.removeIf(new Predicate<Integer>(){
			@Override
			public boolean test(Integer integer){
				return integer % 2 == 0;
			}
		})
		/*
		方法2：调用Iterator接口的remove()方法
		Iterator<Integer> iterator1 = coll.iterator();

		while (coll.hasNext()){
			Integer i = coll.next();
			if (i % 2 == 0){
				coll.remove();
			}
		}
		*/
		 System.out.println("coll中删除偶数后：");
        Iterator<Integer> iterator = coll.iterator();
        while(iterator.hasNext()){
            Integer number = iterator.next();
            System.out.println(number);
        }
	}
}

2.2比较器中使用泛型

2.2.1 举例

package com.atguigu.generic;
public class Circle{
	private double radius;

	public Circle(double radius){
		super();
		this.radius = radius;
	}
	public double getRadius(){
		return radius;
	}
	public void setRadius(double radius){
		this.radius = radius;
	}

	@Override
	public String toString(){
		returen "Circle [radius = " + radius + "]";
	}
}

使用泛型之前

package com.atguigu.generic;

import java.util.Comparator;

class CircleComparator implements Comparator{
	@Override
	public int compare(Object o1, Object o2){
		Circle c1 = (Circle) o1;
		Circle c2 = (Circle) o2;
		return Double.compare(c1.getRadius(), c2.getRadius());
	}
}
public class TestNoGeneric{
	public static void main(String[] args){
		CircleComparator com = new CircleComparator();

		System.out.println(com.compare(new Circle(1), new Circle(2)));

		System.out.println(com.compare("圆1", "圆2"));
		//运行时异常：classCastException
	}
}

使用泛型后

package com.atguigu.generic;

import java.util.comparator

class CurcleComparator1 implements Comparator<Circle> {
	@Override
	public int compare(Circle o1, Circle o2){
		//不再需要强制类型转换，代码更简洁
		return Double.compare(o1.getRadius(), o2.getRadius());
	}
}

public class TestHasGeneric{
	public static void main(String [] args){
		CircleComparator1 com = new CircleComparator1();
		System.out.println(com.compare(new Circle(1), new Circle(2)));

		//System.out.println(com.compare("圆1", "圆2"));
		//编译错误；
	}
}

3.自定义泛型结构

3.1 泛型的基础说明

<类型> 这种语法形式就叫泛型。

1.泛型形式

这种形式我们成为类型参数，这里的“类型”习惯上用T表示，是Type的缩写，即：<T>;
这代表位置的数据类型，我们可以指定很多。

2.在哪里可以声明类型变量

声明类和接口时，再类名或接口名后面声明泛型类型，我们把这样的类或接口称为泛型类或泛型接口

[修饰符] class 类名<类型变量列表> [extends 父类] [implements 接口们]{

}
[修饰符] interface 接口名 <类型变量列表> [implements 接口们]{

}
//例如：
public class ArrayList<E>
public interface Map<K, V> {

}

声明方法时，在修饰符于返回值类型之间声明类型变量，我们把声明了类型变量的方法，称为泛型方法。

[修饰符] <类型变量列表> 返回值类型 方法名 ([形参列表]) [throws 异常列表]{
	//..
}

public static <T> List<T> asList(T... a){

}

3.2 自定义泛型类或泛型接口

当我们在类或接口中定义某个成员时，该成员的相关类型是不确定的，而这个类型需要在使用这个类或接口时才能确定，那么我们可以使用泛型类，泛型接口。

3.2.1 说明

1.我们在声明玩自定义泛型类以后，可以在类的内部(比如属性，方法，构造器中)使用类的泛型。
2.我们在创建自定义泛型类的对象时，可以指明泛型参数类型，一旦指明，内部凡是使用类的泛型参数的位置，都具体化为指定的类的泛型类型。
3.如果在创建自定义泛型类的对象时，没有指明泛型参数类型，那么泛型将被擦除，泛型对应的类型均按照Object处理，但不等同于Object。(泛型要使用一路都要用，要不用，一路都不要用)。
4.泛型的指定中必须使用引用数据类型，不能使用基本数据类型，此时只能使用包装类进行替换。
5.除创建泛型类对象外，子类继承泛型类时，实现类实现泛型接口时，也可以确定泛型结构中的泛型参数。如果我们在给泛型类提供子类时，子类也不确定泛型的类型，可以继续使用泛型参数。我们还可以在现有的父类的泛型参数基础上，新增泛型参数。

3.2.2 注意

1.泛型类可能有多个参数，此时应将多个参数一起放在尖括号里，比如：<E1, E2, E3 >
2.JDK7.0开始，泛型的简化操作：ArrayList<Fruit> fList = new ArrayList<>();
3.如果泛型结构是一个接口或一个抽象类，则不可创建泛型类的对象。
4.不能使用new E[]。但是可以：E [] elements = (E[])new Object[capacity];
5.在接口或类上声明的泛型，在奔雷或本接口表示某种类型，但不可以在静态方法中使用类的泛型。
6.异常类是不能带泛型的。

3.2.3 举例

举例1：

class Person<T> {
	//使用T类型定义变量
	private T info;
	//使用T类型定义一般方法
	public T getInfo(){
		return info;
	}
	public void setInfo(T info){
		this.info = info;
	}
	//使用T类型定义构造器
	public Person(){

	}
	public Person(T info){
		this.info = info;
	}
	// static 的方法中不能声明泛型
	// public static void show(T t){

	//}
	//不能在try-catch中使用泛型定义
	/* public void test(){
		try{

		} catch(MyException<T> ex){

		}
	}*/
}

举例2：

class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son1 extends Father {// 等价于class Son extends Father<Object,Object>{
}
// 2)具体类型
class Son2 extends Father<Integer, String> {
}
// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2> extends Father<Integer, T2> {
}

举例3：

class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son<A, B> extends Father{//等价于class Son extends Father<Object,Object>{
}
// 2)具体类型
class Son2<A, B> extends Father<Integer, String> {
}
// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2, A, B> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2, A, B> extends Father<Integer, T2> {
}

3.3 自定义泛型方法

如果我们定义类，接口时没有使用泛型参数，但是某个方法形参类型不确定时，这个方法可以单独定义泛型参数。

3.3.1 说明

泛型方法的格式

[访问权限] <泛型> 返回值类型 方法名([泛型标识 参数名称]) [抛出的异常]{

}

方法,也可以被泛型化,与其所在的类是否泛型化没有关系.
泛型方法中的泛型参数在方法被调用时确定.
泛型方法可以根据需要声明为static.

3.3.2举例

举例1

public class DAO{
	public <E> E get (int id, E e){
		E result = null;
		return result;
	}
}

举例2

public static <T> void fromArrayToCollection(T[] a, Collection<T> c){
	for (T o : a){
		c.add(o);
	}
}

public static void main(String [] args){
	Object [] ao = new Object[100];
	Collection<Object> co = new ArrayList<Object>();
	fromArrayToCollection(ao, co);
	String [] sa = new String [20];
	Collection<String> cs = new ArrayList<>();
	fromArrayToCollection(sa, cs);

	Collection<Double> cd = new ArrayList<>();

    String[] sa = new String[20];
    Collection<String> cs = new ArrayList<>();
    fromArrayToCollection(sa, cs);
    Collection<Double> cd = new ArrayList<>();
    // 下面代码中T是Double类，但sa是String类型，编译错误。
    // fromArrayToCollection(sa, cd);
    // 下面代码中T是Object类型，sa是String类型，可以赋值成功。
    fromArrayToCollection(sa, co);
}

5.通配符的使用

当我们声明一个变量/形参时,这个变量/形参的类型是一个泛型类或泛型接口,例如:Comparator<T> 类型,但是我们仍然无法确定这个泛型类或泛型接口的类型变量<T>的具体类型,此时我们考虑使用类型通配符?

5.1 通配符的理解

使用类型通配符:?
比如:List<?>是List<String>, List<Object>等各种泛型List的父类

5.2 通配符的读和写

写操作:
将任意元素假如到其中不是类型安全的:

Collection<?> c = new ArrayList<String>();
c.add(new Object());//编译错误

因为我们不知道c的元素类型,我们不能向其中添加对象.add方法有类型参数E作为集合的元素类型.我们传给add的任何参数都必须是一个未知类型的子类.因为我们不知道那是什么类型,所以我们无法传任何东西进去.
唯一可以插入的元素是null,因为他是所有引用类型的默认值

读操作:
另一方面,读取List<?>的对象List中的元素时,永远是安全的,因为不管list的真实类型是什么,它包含的都是Object.

举例1:

public class TestWildcard{
	public static void m4(Collection<?> coll){
		for (Object o : coll){
			System.out.println(o);
		}
	}
}

举例2:

public static void main(String[] args){
	List<?> list = null;
	list = new ArrayList<String>();
	list = new ArrayList<Double>();
	//list = add(3); 编译不通过
	list.add(null);
	

	List<String> l1 = new ArrayList<String>();
	List<Integer> l2 = new ArrayList<Integer>();
	l1.add("尚硅谷");
	l2.add(15);
	read(l1);
	read(l2);
}

public static void read(List<?> list){
	for (Object o : list){
		System.out.println(o);
	}
}