集合概述02

做梦追仙

已于 2022-08-24 22:10:02 修改

阅读量39

点赞数

分类专栏： Collection集合文章标签： java 算法 c++

于 2022-08-24 22:01:00 首次发布

本文链接：https://blog.csdn.net/weixin_44251806/article/details/126513542

版权

Collection集合专栏收录该内容

6 篇文章 0 订阅

订阅专栏

不引入泛型的问题：
当将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，改对象的编译类型变成了Object类型，但其运行时类型任然为其本身类型。因此取出集合元素时需要人为的强制类型转化到具体的目标类型，但是很容易出现ClassCastException异常
那么有没有什么办法可以使集合能够记住集合内元素各类型，且能够达到只要编译时不出现问题，运行时就不会出现java.lang.ClassCastException异常呢？
答案就是使用泛型，可以将运行时的类型检查搬到编译期实现
什么是泛型
泛型是jdk5引入的类型机制，就是将类型参数化。泛型作为一种安全机制而产生泛型机制将类型转换时的类型检查从运行时提前到了编译时，使用泛型编写的代码比杂乱的使用object并在需要时再强制类型转换的机制具有更好的可读性和安全性。
泛型在本质上是指类型参数化。所谓类型参数化，是指用来声明数据的类型本身，也是可以改变的，它由实际参数来决定。在一般情况下，实际参数决定了形式参数的值。而类型参数化，则是实际参数的类型决定了形式参数的类型。
在声明List阶段E是什么类型不确定，这里的E仅仅充当占位符的作用，在具体调用时类型才能确定，而E的所有位置将被指定的类型所替代
使用泛型的定义
public interface List extends Collection
这里的<>中的内容就是类型参数，一般建议使用T或者E之类的全大写
{

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

```
 void add(E element);
```
}
List list=new ArrayList();就是将String传递给E，用于替代定义中的EString str=list.get(0); 不需要进行类型转换
List 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()方法【方法的重载】。
引入泛型的目的实际上就是能够在编写max()方法时，不必确定参数a和b的数据类型，而等到调用的时候再来确定这两个参数的数据类型，那么只需要编写一个max()就可以了，这将大大降低程序员编程的工作量。
Comparable接口—用于类定义中表示当前类型的对象是可比较的，接口中定义了比较方法，要求具体类型提供实现【具体的比较规则】
Java中有一个系统预定义的接口
public interface Comparable { 用于实现规范类的可比较性
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 MyTest {
public static <T extends Comparable> T max(T t1, T t2) {
return t1.compareTo(t2) > 0 ? t1 : t2;
}
}
有界类型
public class MyClass{ } 含义是要求传入T的类型必须是Number或者Number的子类型
在实际应用中可能会需要对传递给类型参数的类型加以限制。比如需要创建一个泛型类，它包含了一个求数组平均值的方法。这个数组的类型可以是整型、浮点型，但显然不能是字符串类型或是其他非数值类型。
Java提供了有界类型bounded types。在指定一个类型参数时，可以指定一个上界，声明所有的实际类型都必须
是这个超类的直接或间接子类。class classname
要求传入的泛型类型必须是Number抽象类的子类
public class Generic{

 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 g=new Generic<>():
double sum=g.sum(1L,2L,3L,4L,5L,6L);
System.out.println(sum);

因为Long是Number的子类，但是换一种类型String则会报错

Generic g=new Generic<>(); //报错的原因是String不是Number的子类型

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

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

Comparable是排序接口

若一个类实现了Comparable接口，就意味着该类支持排序。即然实现Comparable接口的类支持排序，假设现在存在“实现Comparable接口的类的对象的List列表(或数组)”，则该List列表(或数组)可以通
过 Collections.sort（或 Arrays.sort）进行排序。
public interface Comparable {
```
public int compareTo(T o);
```
}
假设我们通过 x.compareTo(y) 来“比较x和y的大小”。若返回“负数”，意味着“x比y小”；
返回“零”，意味着“x等于y”；返回“正数”，意味着“x大于y”。
定义一个可比较的类 — 是为了排序 —排序规则
public class Pig implements Comparable {
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 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类来新建一个比较器”，然后通过该比较器对类进行排序。

如果Pig类并没有实现Comparable接口，调用Collections.sort(list);则代码报错

这是因为在Collections工具类中方法的定义为
public static <T extends Comparable<? super T>> void sort(List list){
list.sort(null);
}

T extends Comparable不是说T必须继承于Comparable接口，而是表示T类型必须实现了
Comparable接口。这里报错就是因为Pig类定义和Comparable接口无关

按照开闭原则不修改源代码，则可以额外引入比较器

Comparator比较接口的定义
@FunctionalInterface 函数式接口，所以可以使用lambda表达式
public interface Comparator {
int compare(T o1, T o2);

boolean equals(Object obj);

default Comparator<T> reversed() {
    return Collections.reverseOrder(this);
}

}

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

List 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 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表达式可能会有报错，但是不一定是程序问题