day-2-3-3

最新推荐文章于 2024-06-22 00:26:36 发布

I＇m昊帝

最新推荐文章于 2024-06-22 00:26:36 发布

阅读量46

点赞数

分类专栏： java实训文章标签： java 算法 c++

本文链接：https://blog.csdn.net/haodi12138/article/details/126513996

版权

java实训专栏收录该内容

51 篇文章 0 订阅

订阅专栏

泛型

不引入泛型的问题：

当将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，改对象的编译类型变成了Object类型，但其运行时类型任然为其本身类型。

因此取出集合元素时需要人为的强制类型转化到具体的目标类型，但是很容易出现ClassCastException异常

那么有没有什么办法可以使集合能够记住集合内元素各类型，且能够达到只要编译时不出现问题，运行时就不会出现java.lang.ClassCastException异常呢？

答案就是使用泛型，可以将运行时的类型检查搬到编译期实现

什么是泛型

泛型是jdk5引入的类型机制，就是将类型参数化。泛型作为一种安全机制而产生
泛型机制将类型转换时的类型检查从运行时提前到了编译时，使用泛型编写的代码比杂乱的使用object并在需要时再强制类型转换的机制具有更好的可读性和安全性。
泛型在本质上是指类型参数化。所谓类型参数化，是指用来声明数据的类型本身，也是可以改变的，它由实际参数来决定。在一般情况下，实际参数决定了形式参数的值。而类型参数化，则是实际参数的类型决定了形式参数的类型。
在声明List阶段E是什么类型不确定，这里的E仅仅充当占位符的作用，在具体调用时类型才能确定，而E的所有位置将被指定的类型所替代

使用泛型的定义

public interface List<E> extends Collection<E>这里的<>中的内容就是类型参数，一般建议使用T或者E之类的全大写

{
	E get(int index);  获取的元素类型就是定义时指定的类型
	void add(E element);
}

List<String> list=new ArrayList<String>();就是将String传递给E，用于替代定义中的E
String str=list.get(0); 不需要进行类型转换

List<Date> list=new ArrayList<>();//这里使用菱形语法，支持泛型推导
list.add("abc");//语法报错，编译时就会进行类型检查
list.add(123);//语法报错
list.add(new Date());
for(int i=0;i<list.size();i++){
    Date temp=list.get(i);   直接获取目标类型，不需要进行类型转换
    System.out.println(temp.getYear()+1900);
}

典型场景

获取两个整数中较大的整数

Integer max(Integer a, Integer b){ 
	return a>b?a:b;      
} 如果需要比较的不是Integer类型，而是Double或是Float类型，那么就需要另外再写max()方法【方法的重载】。
public class MyTest {
	public static <T extends Comparable<T>> T max(T t1, T t2) {
		return t1.compareTo(t2) > 0 ? t1 : t2;
}

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

Comparable接口—用于类定义中表示当前类型的对象是可比较的，接口中定义了比较方法，要求具体类型提供实现【具体的比较规则】

Java中有一个系统预定义的接口

public interface Comparable<T> { 用于实现规范类的可比较性
  	int compareTo(T o);  含义是使用当前对象和参数o对象进行比较当前类型比较时需要返回一个整数,当当前对象大于参数o时，返回一个正数；如果等于时则返回0；如果小于时返回一个负数
}

在定义中可以参数Integer类中的方法实现

public final class Integer  最终类表示Integer不能被继承 
		extends Number  所有的系统预定义的数值类型包装类都继承与Number
 	implements Comparable<Integer>  实现了可比较的接口，当前类不是抽象类，所以必须提供compareTo方法的实现
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);
}

有界类型

public class MyClass<T extends Number>{ } 含义是要求传入T的类型必须是Number或者Number的子类型

在实际应用中可能会需要对传递给类型参数的类型加以限制。比如需要创建一个泛型类，它包含了一个求数组平均值的方法。这个数组的类型可以是整型、浮点型，但显然不能是字符串类型或是其他非数值类型。

Java提供了有界类型bounded types。在指定一个类型参数时，可以指定一个上界，声明所有的实际类型都必须是这个超类的直接或间接子类。class classname <T extends superclass>

要求传入的泛型类型必须是Number抽象类的子类 
public class Generic<T extends Number>{
    public double sum(T... params) {
    	double res=0;
    	for(int i=0;i<params.length;i++)
    		res+=params[i].doubleValue(); //这里是Number中定义的方法
    	return res;
	}
}
注意：这里的extends不表示继承，只是说明传入的类型必须是Number或者Number的子类型
    
调用方法：
Generic<Long> g=new Generic<>():
double sum=g.sum(1L,2L,3L,4L,5L,6L);
System.out.println(sum);  
// 因为Long是Number的子类，但是换一种类型String则会报错
Generic<String> g=new Generic<>(); //报错的原因是String不是Number的子类型

另外调用方式：
Generic<Number> g=new Generic<>();
double sum=g.sum(1,2,3,4,5);  //写法正确，因为Integer(1)也是Number类型的

接口和类都可以用来做上界。class Stats<T extends Comparable>
这里需要注意：针对上界接口使用的关键字仍然是extends而非implements。一个类型参数可以有多个限界，如class Stats<T extends Comparable & Serializable>。限界类型用&分隔，因为逗号用来分隔类型参数。在多个限界中，可以有多个接口，但最多只能有一个类。如果用一个类作为限界，它必须是限界列表中的第一个。

public class Test2 {
	public static void main(String[] args) {
//		MyClass<String> mc = null;
//		MyClass<Date> mc2 = null;
		MyClass<Integer> mc1 = new MyClass<>();
		MyClass<Double> mc2 = new MyClass<>();

		MyClass<Number> mc3 = new MyClass<>();
		mc3.add(123); // Integer是Number的子类型
		mc3.add(12.345);

		Number kk = mc3.get();

		A2<B2> aa = new A2<>();
	}
}

class MyClass<T extends Number> {
	private T id;

	public void add(T t) {
		this.id = t;
	}

	public T get() {
		return id;
	}
}

class A2<T extends Comparable<T> & Serializable> {
}

class B2 implements Comparable<B2>, Serializable {
	public int compareTo(B2 o) {
		return 0;
	}
}

//如果上限类型为类，不是接口，则只能有一个
class C2<T extends Date & Serializable> {

}

Comparable是排序接口

若一个类实现了Comparable接口，就意味着该类支持排序。即然实现Comparable接口的类支持排序，假设现在存在“实现Comparable接口的类的对象的List列表(或数组)”，则该List列表(或数组)可以通过 Collections.sort（或 Arrays.sort）进行排序。

public interface Comparable<T> {
    public int compareTo(T o);
}

假设我们通过 x.compareTo(y) 来“比较x和y的大小”。若返回“负数”，意味着“x比y小”；返回“零”，意味着“x等于y”；返回“正数”，意味着“x大于y”。

定义一个可比较的类  --- 是为了排序   ---排序规则
public class Pig implements Comparable<Pig> {
   private Long id;
   private double weight;
   public int compareTo(Pig obj){
       double res=this.weight-obj.weight;
       if(res>1e-6) return 1;
       else if(res<-1e-6) return -1;
       return 0;
   }
}

List<Pig> list=new ArrayList<>();
Random r=new Random();
for(int i=0;i<10;i++){
    Pig temp=new Pig(1L+i, r.nextDouble()*500);
    list.add(temp);
}
Collections.sort(lit);
for(int i=0;i<list.size();i++) System.out.println(list.get(i));


Collections是集合中所使用的一个工具类，其中提供了一些常见的集合操作方法，例如排序

Comparator是比较器接口

我们若需要控制某个类的次序，而该类本身不支持排序(即没有实现Comparable接口)；那么可以建立一个“该类的比较器”来进行排序。这个“比较器”只需要实现Comparator接口即可。也就是说可以通过“实现Comparator类来新建一个比较器”，然后通过该比较器对类进行排序。

Comparator比较接口的定义

@FunctionalInterface  函数式接口，所以可以使用lambda表达式
public interface Comparator<T> {
    int compare(T o1, T o2);
    
    boolean equals(Object obj);
    
    default Comparator<T> reversed() {
        return Collections.reverseOrder(this);
    }
}

这里将compare和equals声明在一起，是提醒开发者注意两者之间的相关性

List<Pig> list=new ArrayList<>();
Random r=new Random();
for(int i=0;i<10;i++){
    Pig temp=new Pig(1L+i, 500*r.nextDouble());
    list.add(temp);
}
//使用lambda表达式定义
Comparator<Pig> c=(obj1,obj2)->{  泛型声明影响obj1和obj2为Pig类型
    double res=obj1.getWeight()-obj2.getWeight();   //直接调用Pig类中的方法
    if(res>1e-6) return 1;
    else if(res<-1e-6) return -1;
    else return 0;
};
Collections.sort(list, c.reversed());
list.forEach(System.out::println);

//注意：在不同Eclipse版本中编写Lambda表达式可能会有报错，但是不一定是程序问题