0824（038天集合框架03 泛型）

工具编号

已于 2022-08-31 21:13:49 修改

阅读量152

点赞数

分类专栏： java 学习笔记 # 03 Java进阶应用文章标签： java

于 2022-08-24 22:54:33 首次发布

本文链接：https://blog.csdn.net/weixin_48015656/article/details/126514372

版权

java 学习笔记同时被 2 个专栏收录

55 篇文章 0 订阅

订阅专栏

03 Java进阶应用

29 篇文章 0 订阅

订阅专栏

0824（038天泛型01）

0824（038天集合框架03 泛型）

每日一狗（田园犬西瓜瓜）

在这里插入图片描述

泛型

1. 泛型

1.1 引入

为什么要引入泛型以ArrayList

传入数据时无法进行类型检查（传入时会默认转换为Object）
获取的数据都是Object，无法调用其创建类型的独有方法（要用的时候必须进行强制类型转换）
人为强转数据类型经常会出错 java.lang.ClassCastException

为了解决类型安全隐患问题，传入取出的类型转换问题，提高类型安全性，在编译阶段就会对类型进行检测。

解决类型安全隐患
便于程序员及时准确地发现问题
提高可靠性并加快开发速度

平替方案

在泛型出现之前，Java的程序员可以采用一种变通的办法：将参数的类型均声明为Object类型。
由于Object类是所有类的父类，所以它可以指向任何类对象，但这样做不能保证类型安全。

泛型则弥补了Object做法所缺乏的类型安全，也简化了过程，不必显示地在Object与实际操作的数据类型之间进行强制转换。

通过泛型，所有的强制类型转换都是自动和隐式的。因此，泛型扩展了重复使用代码的能力，而且既安全又简单。

1.2 什么是泛型

JDK1.5引入的类型机制：类型参数化。泛型：即将数据类型当作参数进行传递。泛型的本质是类型参数化，将类型转换时的类型检查从运行时提前到了编译时，这个样就可以尽可能的避免因为类型转换所导致的错误。

public interface Comparable<T> { // 可比较接口
    public int compareTo(T o);
}

这里的中的内容T就是类型参数，一般建议使用T(Type)或者E(element元素)之类的全大写。

在声明阶段，这个T/E只是一个占位符，相当于方法中的形参，只有在真实调用的时候才会将指定的类型参数进行传递。

在声明List阶段E是什么类型不确定，这里的E仅仅充当占位符的作用，在具体调用时类型才能确定，而E的所有位置将被指定的类型所替代。

1.3 看一下人家是咋用的

系统是咋用的

// 用于实现规范类的可比较性
public interface Comparable<T> { 
    public int compareTo(T o);
}
// Comparable<Integer> 设定传入可比较的类型 Integer 
public final class Integer 
    // 所有的系统预定义的数值类型包装类都继承与Number
    extends Number 
    // 实现了可比较的接口，当前类不是抽象类，所以必须提供compareTo方法的实现
    implements Comparable<Integer> {
    
    public int compareTo(Integer anotherInteger) {
        return compare(
            this.value,
            anotherInteger.value
        );
    }
    。。。
    public static int compare(int x, int y) {
        return (x < y) ? -1 : ((x == y) ? 0 : 1);
    }
}

1.4 基本使用

规范

针对泛型T使用extends是对传入的T进行类型约束
一般来说再用泛型类的时候前后的泛型参数都是一至的，1.7后可以不用写后边的参数，但是<>还是要写的
泛型中类型的个数没有限制，中间使用,隔开

语法

<? extends E> 上限通配符，用来限制类型的上限，即传入的类型必须直接或间接的继承实现E

<? super E> 下限通配符，用来限制类型的下限。即传入的类型必须是E的父类或E实现的接口

通配符?，通配符只有在创建运行的时候能够找到类型，这种会在写入时报错，无法判定类型，就没有办法添加元素。但是对元素只进行读操作的时候无需特殊操作。

?既不能用于入参也不能用于返参
频繁往外读取内容的，适合用上界extends
经常往里插入的，适合用下界Super

语法糖

JDK1.7+开始支持泛型推导/菱形语法

List<String> list = new ArrayList<String>();
List<String> list = new ArrayList<>(); // 泛型推导/菱形语法

典型应用

需求：获取两个变量之间的比较大的值

如果需要比较的不是Integer类型，而是Double或是Float类型,那么就需要另外再写max()方法【重载】。引入泛型的目的实际上就是能够在编写max()方法时，不必确定参数a和b的数据类型，而等到调用的时候再来确定这两个参数的数据类型，那么只需要编写一个max()就可以了，这将大大降低程序员编程的工作量。

package com.yang1;

public class Test01 {

	public static void main(String[] args) {
		System.out.println(test(5, 6)); // 6
	}
	// 针对泛型T使用extends是对传入的T进行类型约束
	public static <T extends Comparable<T>> T test(T t1, T t2) {
		return (t1.compareTo(t2) > 0) ? t1 : t2;
	}
}

1.5 几个小方向

泛型类

如果定义了泛型类，但是在创建对象的时候没有传入类型时会默认设定为Object类型

A2 a1 = new A2(); // 如果不传入类型即默认会设定为Object类型
a1.setName(Obj); // obj 可以传入任意的数据类型

package com.yang1;

import java.util.Date;

public class Test02 {

	public static void main(String[] args) {
		A2<String, Integer, Date> a1 = new A2<>();
		a1.setId(20);
		a1.setName("wangwu");
		a1.setData(new Date());
		System.out.println(a1.getData().getDate()); // 24
		System.out.println(a1); // A2 [name=wangwu, id=20]
	}

}

class A2<T1, T2, T3> {
	private T1 name;
	private T2 id;
	private T3 data;

	public T3 getData() {
		return data;
	}

	public void setData(T3 data) {
		this.data = data;
	}

	public T1 getName() {
		return name;
	}

	public void setName(T1 name) {
		this.name = name;
	}

	public T2 getId() {
		return id;
	}

	public void setId(T2 id) {
		this.id = id;
	}

	@Override
	public String toString() {
		return "A2 [name=" + name + ", id=" + id + "]";
	}

}

有界类型

可以在传入参数的时候对类型进行范围限定
限定使用<T extends 接口/类> // 定义上界来实现对T类型的必须继承指定类或实现对应的接口
上限进行指定时同一个类型只能继承一个类，可以实现多个接口，中间用&进行分隔

class Test02<T1 extends 
    Number & Comparable<T1> & Serializable> 
{
    // T1这个类型直接或间接的继承了Number实现了Comparable<T1> 和 Serializable两个接口
}

class MyTest<T1 extends Number, T2 extends Comparable<T2>> {
    private T1 t1;
    private T2 t21;
    private T2 t22;

    public T1 getT1() {
        return t1;
    }

    public void setT1(T1 t1) {
        this.t1 = t1;
    }

    public T2 getT21() {
        return t21;
    }

    public void setT21(T2 t21) {
        this.t21 = t21;
    }

    public T2 getT22() {
        return t22;
    }

    public void setT22(T2 t22) {
        this.t22 = t22;
    }

}

泛型方法

泛型方法就是泛型参数在方法中使用到了，普通方法就可以使用类中泛型的类型

但是静态方法就必须通过方法的调用的同时传入泛型

方法和类上都传入了泛型时，采用就近原则来进行类型的定义，没有传入则使用Object类型

package com.yang2;

public class Test01 {

	public static void main(String[] args) {

		// 成员方法的应用
		Test2<String, String> t2 = new Test2<>();
		t2.name = "name";
		t2.printName("String"); // String::class java.lang.String
		
		t2.pp(45); // 45::class java.lang.Integer
		t2.pp("卧槽"); //卧槽::class java.lang.String


		// 静态泛型类的应用
		Test1.pp(5); // lass java.lang.Integer
		Test1.pp("5"); // class java.lang.String

	}

}

class Test2<T1, T2> {
	T1 name;

	void printName(T1 tt) {
		System.out.println(tt + "::" + tt.getClass());

	}
	// 这里的泛型T2是重新传入的，调用方法的时候在重新传入泛型，方法没有传入类型则会默认采用Object来进行声明
	<T2> void pp(T2 t) {
		System.out.println(t + "::" + t.getClass());
	}
}

class Test1 {
	public static <Type extends Object> void pp(Type t) {
		System.out.println(t.getClass());
	}
}

1.6 Comparator和Comparable

这里将compare和equals写在一起为了提醒开发人员这里可能会有二义性，因为排序时使用的数据量只能是compare<=equals；所以compare判定相等不一定equals判定就相等。

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2); 
    boolean equals(Object obj); 
}
public interface Comparable<T> {

    public int compareTo(T o);
}

Comparable是排序接口；若一个类实现了Comparable接口，就意味着“该类支持排序”。而Comparator是比较器；我们若需要控制某个类的次序，可以建立一个“该类的比较器”来进行排序。
Comparable相当于“内部比较器”，而Comparator相当于“外部比较器”。

package com.yang1;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Random;

public class Test04 {

	public static void main(String[] args) {
		List<Pig> ps = new ArrayList<>();
		Random r = new Random();
		for (int i = 0; i < 10; i++) {
			ps.add(new Pig(r.nextDouble() * 20 + 200));
		}
		Collections.sort(ps);
		System.out.println(ps);
        // [Pig [201.28745667269567], Pig [204.5633698990805], Pig [206.90634233144894], Pig [212.07127553335187], Pig [212.5907032865837]]

		// 逆序 return -ress;
		Collections.sort(ps, (Pig o1, Pig o2) -> {
			Double res = o1.getWeight() - o2.getWeight();
			int ress;
			if (res > 1e-6) {
				ress = 1;
			} else if (res < -1e-6) {
				ress = -1;
			} else {
				ress = 0;
			}
			return -ress;
		}

		);
		System.out.println(ps);
        // [Pig [212.5907032865837], Pig [212.07127553335187], Pig [206.90634233144894], Pig [204.5633698990805], Pig [201.28745667269567]]

		// 逆序的逆序 com.reversed()
		Collections.sort(ps, new Comparator<Pig>() {

			@Override
			public int compare(Pig o1, Pig o2) {
				Double res = o1.getWeight() - o2.getWeight();
				int ress;
				if (res > 1e-6) {
					ress = 1;
				} else if (res < -1e-6) {
					ress = -1;
				} else {
					ress = 0;
				}
				return -ress;
			}

		}.reversed());
		System.out.println(ps);
        // [Pig [201.28745667269567], Pig [204.5633698990805], Pig [206.90634233144894], Pig [212.07127553335187], Pig [212.5907032865837]]

	}

}

class Pig implements Comparable<Pig> {
	private Double weight;

	public Pig(Double weight) {
		super();
		this.weight = weight;
	}

	public Double getWeight() {
		return weight;
	}

	public void setWeight(Double weight) {
		this.weight = weight;
	}

	@Override
	public String toString() {
		return "Pig [weight=" + weight + "]";
	}

	@Override
	public int compareTo(Pig o) {
		Double res = weight - o.getWeight();
		if (res > 1e-6) {
			return 1;
		} else if (res < -1e-6) {
			return -1;
		} else {
			return 0;
		}
	}

}

1.7 小案例

创建不确定类型

有一个接口IA，但是具体实现类不确定，具体实现类的创建类的创建交给配置文件，定义类或者方法时，不能确定所需要的参数类型。

实现当时使模板模式用做的排序

package com.yang2;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;

public class Test02 {
	private <T extends Comparable<T>> void sort(List<T> list) {
		for (int i = 1; i < list.size(); i++) {
			for (int j = 0; j < list.size() - i; j++) {
				if (list.get(j).compareTo(list.get(j + 1)) > 0) {
					T tmp = list.get(j);
					list.set(j, list.get(j + 1));
					list.set(j + 1, tmp);
				}
			}
		}
	}

	public static void main(String[] args) {
		Test02 t2 = new Test02();
		List<Integer> list = new ArrayList<>();
		Random r = new Random();
		for (int i = 0; i < 10; i++) {
			list.add(r.nextInt(100));
		}
		System.out.println(Arrays.toString(list.toArray()));
		// [7, 31, 69, 39, 59, 71, 54, 99, 57, 17]
		t2.sort(list);
		System.out.println(Arrays.toString(list.toArray()));
		// [7, 17, 31, 39, 54, 57, 59, 69, 71, 99]
	}
}

1.8 泛型类的继承

泛型类也是可以继承的，任何一个泛型类都可以作为父类或子类。不过泛型类与非泛型类在继承时的主要区别在于：

就是父类定义了一个泛型，子类在定义的时候，如果要用这个对应的泛型，就在继承的时候将对应的泛型给传过去，不用则默认使用Object填充类型
- 子类不是泛型类：需要给父类传递类型常量，如class Aa extends A<String>，如果不设置则默认为class Aa extends A<Object>
- 子类是泛型类：可以给父类传递类型常量，也可以传递类型变量。如class AA3<E> extends A<E>

如果父类中泛型有约束

public class A1<T extends Serializable> {}
// //声明子类型时在子类上声明约束
public class B1<D extends Serializable> extends A1<D>{}  
// 可以写成，此时A1中T就是Object类型的
public class B1<D extends Serializable> extends A1{}

1.8 问：泛型的擦除与补偿

泛型的擦除和补偿这两个机制都是编译器内部自动完成的。其实从编写程序的时候就可以发现了，getT方法没有报错就说名他已经将擦除和补偿工作干完了，此时泛型就已经是String类型了。
public class Test01 {
	public static void main(String[] args) {
		A1<String> s = new A1<>();
        // 这里没有报错就说明当前getT的返回值就已经是String了
		String ss = s.getT("gd"); 
	}
}
class A1<T> {
	T getT(T t) {
		return t;
	}
}

从虚拟机的角度上来讲，不存在泛型的概念。泛型只存在于编译期，就是在编译的时候，运行的时候会将泛型进行擦除与补偿，泛型就是将运行时才可能会出的类型转换异常给你提前到编译期，如果类型转换成功编译通过，否则编译失败且报错类型异常。

编译后产生的二进制字节码文件中还有泛型的标志，可以通过反编译看到，但是这个的泛型只是一个架子，相当于时形参，你总不能指望你指定一个类型他就给你重新搞一个类吧。

一句话总结就是：在.java文件运用泛型技术时，编译器在文件编译通过后运行时自动擦除泛型标识。

如果需要使用泛型的类型，则需要通过反射机制进行保存。

**问：**由于泛型的擦除，运行时并没有泛型机制，同时也没有使用向下类型转换，那么为何运行时无异常？

这是由于泛型的补偿

List<String> list=new ArrayList<>();
for(String tmp:list) System.out.println(tmp.length()); // 泛型的补偿
// 编译器在擦除泛型后，会自动将类型转换为原定义的泛型，这样就不必再做向下类型转换了。
for(Object tmp:list){
	if(tmp instanceof String){
        System.out.println(((String)tmp).length());
	}
}

1.9 泛型的局限性

不能使用基本类型
不能使用泛型类异常
不能使用泛型数组

不能实例化参数类型对象。例如T ob = new T();

2. 对象的克隆

不可变类：对于变量的修改操作都会引发对象的新建。

在浅克隆中，对于String类型的属性进行修改的时候，会创建新的String对象，所以对于字符串引用数据类型并不能达到操作同一对象的效果。

2.1 深克隆

如果需要实现深克隆，可以通过对象流【Serializable】实现，会将所有相关的内容进行一次拷贝，而不会针对复杂类型属性只是拷贝地址(浅克隆)

package com.yang2;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Test05 implements Serializable {
	private static final long serialVersionUID = 5151265987970993566L;
	private int id;
	private String name;
	private StringBuffer name2;

	public Test05(int id, String name, StringBuffer name2) {
		super();
		this.id = id;
		this.name = name;
		this.name2 = name2;
	}

	@Override
	public String toString() {
		return "Test04 [id=" + id + ", name=" + name + ", name2=" + name2 + "]";
	}

	public static void main(String[] args) throws Exception {
		// 创建被克隆对象
		Test05 t1 = new Test05(20, "xiaoming", new StringBuffer("wcazo"));
		// 创建内存存储对象
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		ObjectOutputStream oos = new ObjectOutputStream(baos);
		// 写出数据
		oos.writeObject(t1);
		// 输出内存流中的数据转换为字节数据传入数据读中
		ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()));
		// 重新读回数据
		Test05 t2 = (Test05) ois.readObject();
		;
		t1.name = "我改过了"; // 不可变数据类型
		t1.id = 50; // 不可变数据类型
		t1.name2.append("false"); // 可变数据类型
		System.out.println(t1); // Test04 [id=50, name=我改过了, name2=wcazofalse]
		System.out.println(t2); // Test04 [id=20, name=xiaoming, name2=wcazo]

	}

}

2.2 浅克隆

使用 Object clone() 方法来进行浅克隆

package com.yang2;

public class Test04 implements Cloneable {
	private int id;
	private String name;
	private StringBuffer name2;

	public Test04(int id, String name, StringBuffer name2) {
		super();
		this.id = id;
		this.name = name;
		this.name2 = name2;
	}

	@Override
	public String toString() {
		return "Test04 [id=" + id + ", name=" + name + ", name2=" + name2 + "]";
	}

	@Override
	public Object clone() throws CloneNotSupportedException {
		return super.clone();
	}

	public static void main(String[] args) throws CloneNotSupportedException {
		Test04 t1 = new Test04(20, "xiaoming", new StringBuffer("wcazo"));
		Test04 t2 = (Test04) t1.clone();
		t1.name = "我改过了"; // 不可变数据类型
		t1.id = 50; // 不可变数据类型
		t1.name2.append("false"); // 可变数据类型
		System.out.println(t1); // Test04 [id=50, name=我改过了, name2=wcazofalse]
		System.out.println(t2); // Test04 [id=20, name=xiaoming, name2=wcazofalse]

	}

}

扩展小芝士

开闭原则：对于修改关闭，对于扩展开放
利用反射机制创建类

package com.yang2;

import java.lang.reflect.Method;

public class Test03 {
	public static void main(String[] args) throws Exception {
		// 利用反射机制创建对象
		String class_ = "java.util.Date";
		System.out.println(Class.forName(class_).newInstance()); // Wed Aug 24 16:51:57 CST 2022
		
		// 利用反射调用私有方法
		A3 a3 = new A3();
		Method method = a3.getClass().getDeclaredMethod("pp");
		method.setAccessible(true);
		System.out.println(method.invoke(a3)); // pirvate fun
	}

}

class A3 {
	private String pp() {
		return "pirvate fun";
	}
}