Comparable 和 Comparator的区别&对泛型的一些理解
Comparable 接口
直接看api
public interface Comparable<T>{
public int compareTo(T o)
}
可以看出这个泛型接口里,只有一个compareTo方法,参数是同类型的泛型变量,如果我们需要用到比较或者排序方法,我们只需要在这个类上实现以下Comparable接口就可以了,重写compareTo方法。
此外,一些基本的类型也实现了Comparable接口,像Integer、String类型。
该方法返回一个 int 类型的数据,但是此 int 的值只能是一下3种:
1:表示大于
-1:表示小于
0:表示相等
使用方法也很简单:
package Test;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Node extends PeopleInSchool implements Comparable<Node>{
@Override
public int compareTo(Node o) {
if(this.Id.compareTo(o.Id)>0) return 1;
else if(this.Id.compareTo(o.Id)==0) return 0;
else return -1;
}
public static void main(String[] args) {
Node[] t = new Node[20];
for(int i=0;i<20;i++) {
Node node = new Node();
node.Id = Test1.RandomId(1); //这边就是自己手写的随机生成字符串函数,就不展示了。
t[i] = node;
}
Arrays.sort(t);
for(int i=0;i<20;i++){
System.out.println(t[i].Id+" "+t[i].Name);
}
}
}
PeopleInSchool类:
package Test;
public class PeopleInSchool {
public String Id;
public String Name;
}
运行结果:
Comparator接口
比较器接口,我们看下api
public interface Comparator<T>{
int compare(T o1, T o2);
boolean equals(Object obj); //可以不实现
}
所以我们只需要实现以下compare()方法就可以实现两个类的比较,有点像C++的自定义排序
//C++里是这么写的:
bool cmp(node a,node b){
if(a.id!=b.id) return a.id<b.id;
else return a.name<b.name;
}
sort(a+1,a+1+n,cmp);
类比过来
package Test;
import java.util.Arrays;
import java.util.Comparator;
public class Node1 extends PeopleInSchool implements Comparator<Node1> {
@Override
public int compare(Node1 o1, Node1 o2) {
if(o1.Id.compareTo(o2.Id)>0) return 1;
else if(o1.Id.compareTo(o2.Id)==0) return 0;
else return -1;
}
public static void main(String[] args) {
Node[] t = new Node[20];
for(int i=0;i<20;i++) {
Node node = new Node();
node.Id = Test1.RandomId(1);
t[i] = node;
}
Arrays.sort(t);
for(int i=0;i<20;i++){
System.out.println(t[i].Id+" "+t[i].Name);
}
}
}
运行结果:
还有一种类似的写法
public class Node1 extends PeopleInSchool {
// @Override
// public int compare(Node1 o1, Node1 o2) {
// if(o1.Id.compareTo(o2.Id)>0) return 1;
// else if(o1.Id.compareTo(o2.Id)==0) return 0;
// else return -1;
// }
public static void main(String[] args) {
Comparator<Node> cmp = new Comparator<Node>() { //匿名类,接口实例化
@Override
public int compare(Node o1, Node o2) {
if(o1.Id.compareTo(o2.Id)>0) return 1;
else if(o1.Id.compareTo(o2.Id)==0) return 0;
else return -1;
}
};
Node[] t = new Node[20];
for(int i=0;i<20;i++) {
Node node = new Node();
node.Id = Test1.RandomId(1);
t[i] = node;
}
Arrays.sort(t,cmp);
//Arrays.sort(t,(Node o1,Node o2) -> (o1.Id.compareTo(o2.Id))) 直接使用lambda表达式
//Arrays.sort(t,Comparetor.comparing((Node a) -> a.Id); 更高级的写法
//关于comparing方法,可以看这篇博客https://blog.csdn.net/rungong123/article/details/88421272
for(int i=0;i<20;i++){
System.out.println(t[i].Id+" "+t[i].Name);
}
}
}
对比Comparable 和 Comparator,Comparable可以认为是一个内比较器,实现了Comparable接口的类有一个特点,就是这些类是可以和自己比较的,Comparator可以认为是是一个外比较器,比如需要多种方式排序的时候可以定义多个 Comparator cmp。
关于比较器的底层原理,是通过二叉搜索树中序遍历得到,时间复杂度nlog(n)。
关于泛型的一些理解
举一个例子,
ArrayList dates = new ArrayList();
dates.add(new Date());
Data data = dates.get(0);
这段程序会报错,我们知道没有泛型的话,ArrayList里面装的默认是Object变量,Date类是Object类的子类,new Date()可以装入dates中,但是get方法返回的也是一个Object类型的变量,不可以赋值给date,所以这时候我们要强转为(date类型)
ArrayList dates = new ArrayList();
dates.add(new Date());
Data data = (Date)dates.get(0);
- 自己写泛型类,把泛型当成一个可以用Integer或者String替代的类,需要使用泛型类的时候,再用自己需要的类进行替换
- 泛型存在于编译时。一旦编译器确认泛型类型是安全使用的,就会将它转换为原生类型。也就是说编译通过后,泛型就不存在了。
- 泛型的作用是让我们可以在编译的时候而不是运行的时候发现错误
- 对于泛型方法,我认为是函数参数中出现了泛型参数
像下图所示
图中SortUtil不是一个泛型类,但它有两个泛型方法,如果去掉了public 后边的< T>,相当于参数中的List的类型T没有声明,会报错
通配泛型
通配泛型有三种形式:?、? extends T、? super T,其中T是泛型类型
第一种形式?称为非受限通配,没有限制。第二种称为受限通配,表示T或者T的一个子类。第三种形式? super T称为下限通配,表示T或者T的父类。
例子可以看《JAVA语言程序设计进阶篇11版》第11页,比较好理解,包括Comparator上面提到的PeopleInschool,就用到了受限通配,T必须是PeopleInschool的子类
关于泛型数组,其实这玩意没多少人会用,ArrayList< T> 它不香吗?奈何课后作业里给了一题用泛型数组模拟队列的,这边贴贴以后看。
题目要求:
修改程序清单19-1中的GenerisStack类,使用数组而不是ArrayList来实现它。需要在给栈添加新元素之前检查数组的大小。如果数组满了,则创建一个新数组,该数组容量是原先数组容量的两倍,然后将当前数组的元素复制到新数组当中
import java.lang.reflect.Array;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class GenericStack<T>{
private T[] a;
int len;
int top;
public GenericStack(){ //无参构造
this.len = 1;
this.top = 0;
a = (T[]) new Object[this.len]; //强制类型转换成T泛型类型
}
//之后就是正常的数组模拟
public T peek(){
return a[top-1];
}
public void push(T o){
if(top == len){
T[] temp = (T[]) new Object[this.len*2];
for(int i=0;i<this.len;i++){
temp[i] = this.a[i];
}
this.a = temp;
this.len = this.len*2;
}
this.a[top++] = o;
}
public T pop(){
T x = this.a[top-1];
this.top--;
return x;
}
}
泛型擦除
上面提到泛型只存在于编译时,使用泛型类型来编译代码,随后会擦除它,这就叫泛型擦除,所以这边有几个结论:
- 当编译泛型类、接口和方法时,编译器会用Object类型替代泛型类型
- 如果一个泛型类型是受限的,编译器就会用Object类型来替换它
- 泛型类型是被它的所有实例所共享的(注意:ArrayList< String>并没有在JVM中存储为单独的一个类)
- 由于泛型类型在运行时被擦除,因此对于如何使用泛型类型是有一定限制的。
//不能使用new T(),这样是错误的
T object = new T()
//不能使用new T[],这样是错误的,泛型数组需要使用我之前栈例子的写法
T[] temp = new T[10];
//泛型数组正确写法
T[] array = (T[])new Object[]; //通过Object数组强制转换
之后学习了再更新吧,还有好多不会