Java 接口之 Comparable、Comparator和Cloneable

最新推荐文章于 2024-07-10 21:37:49 发布

IT自习小空间

最新推荐文章于 2024-07-10 21:37:49 发布

阅读量495

点赞数

分类专栏： java 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/jiangnb520/article/details/121452486

版权

java 专栏收录该内容

30 篇文章 2 订阅

订阅专栏

文章目录

一、Comparable接口
二、Comparator接口
三、Cloneable接口

一、Comparable接口

接口不是类，而是对类的一组需求描述，这些类要遵从接口描述的统一格式进行定义。
Arrays类中的sort方法承诺可以对对象数组进行排序，但要求满足下列前提：对象所属的类必须实现了Comparabe接口

下面是Comparable接口代码

public interface Comparable<T> {
    public int compareTo(T o);
}

该接口对实现它的每个类的对象强加一个整体排序。这个排序被称为类的自然排序，类的compareto方法被称为其自然比较方法。
Collections.sort （和Arrays.sort ）可以自动对实现此接口的对象进行列表（和数组）排序。

在实现Comparable<T>接口的类中，必须提供下面这个方法。

public int compareTo(T o);

1、当没有实现Comparable接口时

class Student {

    private String name;
    private int age;
    private float score;

    public Student(String name, int age, float score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}

public class InterfaceTest {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("小明", 20, 68);
        students[1] = new Student("小红", 21, 78);
        students[2] = new Student("小李", 20, 99);
        System.out.println(Arrays.toString(students));
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}

上述代码会抛出异常
在这里插入图片描述
因为sort方法不知道依据哪个属性进行排序。所以，利用sort想要对象实现排序功能，就必须提供对象的比较方法，这个时候就需要使用Comparable和Comparator

2、当实现Comparable接口

class Student implements Comparable<Student> {

    private String name;
    private int age;
    private float score;

    public Student(String name, int age, float 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.age - o.age;
    }
}

public class InterfaceTest {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("小明", 20, 68);
        students[1] = new Student("小红", 21, 78);
        students[2] = new Student("小李", 20, 99);
        System.out.println(Arrays.toString(students));
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}

这时Student实现了Comparable接口，并且重写了compareto方法，compareto方法表示当前对象与参数中的对象进行比较，返回值为你要比较的方式，如果比较两个对象的年龄，就让当前对象的年龄减去参数中对象的年龄。
在这里插入图片描述
最终sort方法就完成了对对象的排序。

二、Comparator接口

Comparator是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足要求时，可写一个比较器来完成两个对象之间大小的比较。

class Person {
    private String name;
    private int age;
    private double rise;

    public Person(String name, int age, double rise) {
        this.name = name;
        this.age = age;
        this.rise = rise;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getRise() {
        return rise;
    }

    public void setRise(double rise) {
        this.rise = rise;
    }

    @Override
    public String toString() {
        return "person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", rise=" + rise +
                '}';
    }
}
class NameComparator implements Comparator<Person> {
    @Override
    public int compare(Person o1, Person o2) {
        return o1.getName().compareTo(o2.getName());
    }
}
class AgeComparator implements Comparator<Person> {
    @Override
    public int compare(Person o1, Person o2) {
        return o1.getAge() - o2.getAge();
    }
}
class RiseComparator implements Comparator<Person> {
    @Override
    public int compare(Person o1, Person o2) {
        return (int)(o1.getRise() - o2.getRise());
    }
}

public class InterfaceTest {

    public static void main(String[] args) {
        Person[] person = new Person[3];
        person[0] = new Person("小明", 20, 168.2);
        person[1] = new Person("小红", 21, 178.4);
        person[2] = new Person("小李", 20, 199);

        NameComparator nameComparator = new NameComparator();
        Arrays.sort(person, nameComparator);
        System.out.println(Arrays.toString(person));

        AgeComparator ageComparator = new AgeComparator();
        Arrays.sort(person, ageComparator);
        System.out.println(Arrays.toString(person));

        RiseComparator riseComparator = new RiseComparator();
        Arrays.sort(person, riseComparator);
        System.out.println(Arrays.toString(person));
    }
}

上述代码中，我们实现了三种比较器，每个比较器都是一个类，而且实现了Comparator接口，重写了compare方法。

public int compare(Person o1, Person o2) {
        return o1.getAge() - o2.getAge();
    }

o1 - 要比较的第一个对象。
o2 - 要比较的第二个对象。

三、Cloneable接口

clone方法是在Object种定义的,而且是protected型的,只有实现了这个接口，才可以在该类的实例上调用clone方法,否则会抛出CloneNotSupportException。

public class CloneTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        Animal animal = new Animal();
        Animal animal1 = (Animal) animal.clone();
    }
}
class Dog {
    public int rise = 80;
}
class Animal implements Cloneable {
    private String name;
    private int age;
    public Dog dog = new Dog();

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void run() {
        System.out.println("Animal.run");
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

需要注意的是：我们进入clone方法（下方代码段），该clone的类型为Object，所以调用clone方法的时候应该强制转换为Animal，而且当前的Animal对象必须是可以被clone的，所以Animal类要实现cloneable接口。而当我们使用clone方法的时候，需要重写clone方法，并且抛出一个异常

 protected native Object clone() throws CloneNotSupportedException;

下面看animal和animal1的大致内存图。
在这里插入图片描述
Object中默认的实现是一个浅拷贝,也就是表面拷贝,如果需要实现深层次拷贝的话,必须对类中可变域生成新的实例。这个时候就体现了为什么要重写clone方法。

public class CloneTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        Animal animal = new Animal("小明", 21);
        Animal animal1 = (Animal) animal.clone();
        animal1.dog.rise = 10;
        System.out.println(animal.toString());
        System.out.println(animal1.toString());
    }
}
class Dog implements Cloneable {
    public int rise = 80;
    
    @Override
    public String toString() {
        return "Dog{" +
                "rise=" + rise +
                '}';
    }

	@Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Animal implements Cloneable {
    private String name;
    private int age;
    public Dog dog = new Dog();

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", dog=" + dog +
                '}';
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        Animal tmp = (Animal) super.clone();
        tmp.dog = (Dog) tmp.dog.clone();
        return tmp;
    }
}

我们来对比重写clone的代码

对于当前代码浅拷贝实现方式

	@Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

对于当前代码深拷贝实现方式

	@Override
    public Object clone() throws CloneNotSupportedException {
        Animal tmp = (Animal) super.clone();
        tmp.dog = (Dog) tmp.dog.clone();
        return tmp;
    }

对比之后发现，其实多了层对Dog类的克隆，当克隆完之后新的tmp对象与之前被克隆对象互不影响。从而达成深拷贝。最后返回新对象。

IT自习小空间

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java 接口之 Comparable、Comparator和Cloneable

文章目录一、Comparable接口二、Comparator接口三、Cloneable接口一、Comparable接口接口不是类，而是对类的一组需求描述，这些类要遵从接口描述的统一格式进行定义。Arrays类中的sort方法承诺可以对对象数组进行排序，但要求满足下列前提：对象所属的类必须实现了Comparabe接口下面是Comparable接口代码public interface Comparable<T> { public int compareTo(T o);}该接口
复制链接

扫一扫