java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Java Comparable Comparator Clonable

深入分析Comparable与Comparator及Clonable三个Java接口

作者：xaiobit_hl

接口不是类，而是对类的一组需求描述，这些类要遵从接口描述的统一格式进行定义，这篇文章主要为大家详细介绍了Java的Comparable,Comparator和Cloneable的接口，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下，希望能够给你带来帮助

1.Comparable

这个接口是用来给对象数组来排序的

在我学接口之前我用的排序方法是Arrays.sort()，我发现单单靠之前所学知识并不能解决给对象数组排序的问题，后来学习过程中发现Comparable这一接口解决了我的疑惑，也感受到了这一接口的强大之处，但这也不是最好的，后续会说到，毕竟学知识是个循序渐进的过程嘛

首先，我们看一下我们之前学习时用的Arrays.sort

public class TestDemo {
    public static void main(String[] args) {
        int[] array = {1,3,6,2,4};
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
    }
}

它能将整形数组从小到大排序，，，下面我们再来看一下Arrays.sort给对象数组排序（错误示范）

class Student {
    public String name;
    public int age;
    public double score;
 
    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("zhangsan",98,78.9);
        students[1] = new Student("lisi",38,48.9);
        students[2] = new Student("wangwu",18,88.9);
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}

当我们写出这样一个代码的时候，我们会发现运行结果是个什么东西？？？

这时候不要慌，简单分析一下报错原因，我们可以看到它报了一个ClassCastException（类型转换异常），根据后面的稍微能看懂的几个英文（小编自己英文水平太差，所以只能看懂几个），可以大概的知道是说Student不能转换为java.lang包下的Comparable，这时候我们点进去看一下源码，不要害怕看源码，有时候我们往往只需要看懂一点就能明白错误的原因了

经过粗略的分析if条件语句这一行，发现数组取下标呢，元素与元素之间都用compareTo来比较，这时候，我们发现其中的猫腻了，，，我们打开帮助手册查一下Comparable，发现它是一个泛型接口，，并且它有一个抽象方法compareTo,这时候面纱就将要一层一层的揭开了

compareTo方法中这一大段画，看到第一行我们就明白了，这东西可以帮我们解决数组对象的比较问题，所以我们要拿Student这个类去实现Comparable，并且实现compareTo方法，就能做到对象数组的排序了，看代码：

class Student implements Comparable<Student>{
    public String name;
    public int age;
    public double score;
 
    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
    @Override
    public int compareTo(Student o) {
        //return this.name.compareTo(o.name);
        //return this.age - o.age;
        return (int)(this.score-o.score);
    }
}

这时候Arrays.sort()就可以帮我们做到对象数组的排序了，在 sort 方法中会自动调用 compareTo 方法. compareTo 的参数是 Object , 其实传入的就是 Student 类型的对象.

然后比较当前对象和参数对象的大小关系 (例如按score ).

如果你对姓名的比较存在疑惑，比如：为什么name也可以调用compareTo方法这种类似的问题，因为name是String类型的，我建议你先看一下String的源码，里面也实现了Comparable接口，以及重写了compareTo方法，这里就不详细介绍了，感兴趣的小伙伴们可以尝试一下哦，当然，我相信你们都是大佬，一看就懂哈哈

执行程序，看运行结果，这下就能达到我们想要的效果了 

前面说了，这样的代码也不是最好的，存在局限性，我按分数来排序，那代码就写死了 ，那我以后想按姓名来排序，我又得回头改？？？，以后进公司了，你的代码做改变，影响其他人的代码，那不得把你骂死，所以我们需要做进一步改进，引入Comparator接口

2.Comparator比较器

这个接口又叫比较器，那比较器又是个什么东西呢？？？下面我也是老套路啦，一步一步揭开这东西的面纱

为了解决Comparable接口的局限性，我们这个比较器完美的展现了实现效果，它也是一个泛型接口，同样只有一个抽象方法需要重写，下面看代码：

class Student {
    public String name;
    public int age;
    public double score;
    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}
//比较器
class AgeComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age - o2.age;
    }
}
class StringComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}
class ScoreComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return (int)(o1.score-o2.score);
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("zhangsan",98,78.9);
        students[1] = new Student("lisi",38,48.9);
        students[2] = new Student("wangwu",18,88.9);
        /*AgeComparator ageComparator = new AgeComparator();
        Arrays.sort(students,ageComparator);
        StringComparator stringComparator = new StringComparator();
        Arrays.sort(students,stringComparator);*/
        ScoreComparator scoreComparator = new ScoreComparator();
        Arrays.sort(students,scoreComparator);
        System.out.println(Arrays.toString(students));
    }
}

通过这段代码，我们发现比较器是真真正正的做到了，想按什么排序就按什么排序，在对类的侵入性以及代码耦合度方面也算是不用太过担心了

3.Clonable接口和深拷贝

Java 中内置了一些很有用的接口 , Clonable 就是其中之一 .

Object 类中存在一个 clone 方法 , 调用这个方法可以创建一个对象的 " 拷贝 ". 但是要想合法调用 clone 方法 , 必须要先实现 Clonable 接口 , 否则就会抛 CloneNotSupportedException 异常.

先来看一段代码吧，我个人喜欢结合代码看分析，这样子就降低了云里雾里的可能性了，

class Student implements Cloneable{
    public int id = 1234;
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                '}';
    }
    //重写Object父类的clone()方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Student student1 = new Student();
        try {
            Student student2 = (Student) student1.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

实现克隆的两个条件（结合上面代码）：

1.这个对象可以被克隆，也就是这个Student类要实现这个Clonable接口

2.要在这个类中重写父类Object的clone（）方法

我们现在的代码只是达到了这样一个效果，，重头戏还在后边，因为我们的拷贝有时候远远不止于此，这种只能算是一个浅拷贝，那什么才算是深拷贝呢？？？ 请看下面的代码：

class Money implements Cloneable{
    public double money = 19.9;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Student implements Cloneable{
    public int id = 1234;
    public Money m = new Money();
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                '}';
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class TestDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student student1 = new Student();
        //为了代码的好看，我这里不处理这个异常
        Student student2 = (Student) student1.clone();
        System.out.println(student1.m.money);
        System.out.println(student2.m.money);
        System.out.println("=========================");
        student1.m.money = 99.99;
        System.out.println(student1.m.money);
        System.out.println(student2.m.money);
    }
}

我现在在之前的代码的基础上添加了一个Money类，并且实例化Money的对象作为Student的成员，这时候克隆之后，改变我money的值，会是一个什么的效果呢？？？

先看运行结果吧，我就不兜圈子了 

我们发现，这并不是我们想要的结果，我们想要的结果是，通过student2去改变money的值，它并不会影响student1中的money，而我们刚刚的代码并没有做到，它的效果图如下：

那又如何做到深拷贝呢？？这时我们就需要对我们刚才的代码做一些改进了 

我们只需将原来的Student类中的Object的克隆方法改成下面这份代码就能做到我们想要的效果：

@Override
    protected Object clone() throws CloneNotSupportedException {
        Student tmp = (Student) super.clone();//将id变量克隆一份，tmp指向它
        tmp.m = (Money) this.m.clone();//将m对象中的money变量克隆一份  tmp中的m指向它
        return tmp;
        //return super.clone();
    }

看到这个代码先不要慌，如果注释没看明白，咱还有板书可以参照

其实分析起来也就那么回事

当我们tmp返回的时候，就把0x99给到了student2，克隆完成之后，tmp是局部变量，也就被回收了，，，就变成了下面这副摸样：

这个时候，我们再去通过student2去改变我们的money，就不会影响student1中的money的值了，废话不多说，运行结果为证

以上就是三个重要接口的全部分析了，下次再见！！！ 

到此这篇关于深入分析Comparable与Comparator及Clonable三个Java接口的文章就介绍到这了,更多相关Java Comparable Comparator Clonable内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文