亲宝软件园·资讯

展开

Java Comparable Comparator Clonable

xaiobit_hl 人气:0

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的值了，废话不多说，运行结果为证

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

加载全部内容
相关教程
猜你喜欢
用户评论