Comparable 和 Comparator的区别&对泛型的一些理解

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数组强制转换

之后学习了再更新吧，还有好多不会