Java三大常用接口-----Comparable Comparator Cloneable(包含深拷贝和浅拷贝讲解)

前言
由于Comparable和Comparator密切相关,所以我们先介绍这两个接口!

1. 简述Comparable Comparator

Java中的排序是由Comparable和Comparator这两个接口来提供的。
Comparable表示可被排序的，实现该接口的类的对象自动拥有排序功能。
Comparator则表示一个比较器，实现了该接口的的类的对象是一个针对目标类的对象定义的比较器，一般情况，这个比较器将作为一个参数进行传递。

1.1 Comparable接口

这个接口一般用于内部比较,侵入性比较强,也就是不太灵活!
我们来具体看例子说话:

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
class Student implements Comparable<Student>{
    private String name;
    private int score;
    private int age;
public Student(String name,int score,int age){
    this.name=name;
    this.score=score;
    this.age=age;
}

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

    @Override
    public int compareTo(Student o) {
        //return this.score-o.score;//用成绩排
        //return this.name.compareTo(o.name);//用姓名排
        return this.age-o.age;//用年龄排
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Student[] studens= {new Student("wang",99,18),
                            new Student("sun",93,11),
							new Student("li",95,13)
		};
        for (int i = 0; i < studens.length; i++) {
            System.out.println(studens[i].toString());
        }
        System.out.println();
        Arrays.sort(studens);
        for (int i = 0; i < studens.length; i++) {
            System.out.println(studens[i].toString());
        }
    }
}    

当我们对自定义对象进行排序时,我们的得指定一个排序的基准,比如以成绩或者年龄或者姓名.
但是用这种方法,我们的面临着一个问题,比如我们一开始是以成绩来排的,现在我们想用年龄来排,那这就得去修改,个人还好,如果在一个公司中呢?你一改,别人都得跟着改,这不是牵一发而动全身吗??
所以我们可以使用Comparator这个接口来实现!

1.2 Comparator接口

这个接口我们可以称为外部比较器,因为与Comparable相比而言,他是单独在外部实现类来进行排序的!

sort中有这个方法!

我们来看看怎么实现吧:

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Random;
import java.util.Scanner;
class Student{
    public String name;
    public int score;
    public int age;
    public Student(String name,int score,int age){
        this.name=name;
        this.score=score;
        this.age=age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", score=" + score +
                ", age=" + age +
                '}';
    }
}
class AgeComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age-o2.age;
    }
}
class ScoreComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.score-o2.score;
    }
}
class NameComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Student[] studens= {new Student("wang",99,18),
new Student("sun",93,11),
new Student("li",95,13)};
        for (int i = 0; i < studens.length; i++) {
            System.out.println(studens[i].toString());
        }
        System.out.println("分数比较");
        ScoreComparator scoreComparator=new ScoreComparator();
        Arrays.sort(studens,scoreComparator);
        for (int i = 0; i < studens.length; i++) {
            System.out.println(studens[i].toString());
        }
        System.out.println("姓名比较");
        NameComparator nameComparator=new NameComparator();
        Arrays.sort(studens,nameComparator);
        for (int i = 0; i < studens.length; i++) {
            System.out.println(studens[i].toString());
        }
        System.out.println("年龄比较");
        AgeComparator ageComparator=new AgeComparator();
        Arrays.sort(studens,ageComparator);
        for (int i = 0; i < studens.length; i++) {
            System.out.println(studens[i].toString());
        }
    }

大家看这样是不是灵活多了,我想用啥比较就用啥比较,简直

1.3 二者比较

Comparable可以看做是内部比较器，Comparator可以看做是外部比较器。
一个类，可以通过实现Comparable接口来自带有序性，也可以通过额外指定Comparator来附加有序性。

2.Cloneable接口

2.1简述

Cloneable是标记型的接口，它们内部都没有方法和属性，实现 Cloneable来表示该对象能被克隆，能使用Object.clone()方法。如果没有实现 Cloneable的类对象调用clone()就会抛出CloneNotSupportedException。
也就是说Cloneable接口赋予类可以被克隆的属性!

2.2克隆的分类

浅克隆（shallow clone），浅克隆是指拷贝对象时仅仅copy对象本身和对象中的基本变量，而不拷贝对象包含的引用指向的对象。

深克隆（deep clone），不仅copy对象本身，而且copy对象包含的引用指向的所有对象。

举例：对象X中包含对Y的引用，Y中包含对Z的引用。浅拷贝X得到X1，X1中依然包含对Y的引用，Y中依然包含对Z的引用。深拷贝则是对浅拷贝的递归，深拷贝X得到X1，X1中包含对Y1（Y的copy）的引用，Y1中包含对Z1（Z的copy）的引用。

2.3 克隆代码举例

要让对象可以被克隆，应具备以下2个条件：

让该类实现java.lang.Cloneable接口；
重写（Override）Object的clone()方法；

class Person implements Cloneable{
    private String name;
    private int age;
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }

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

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

public class TestDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1=new Person("xiaohong",20);
        Person person2=(Person) person1.clone();
        System.out.println(person2.toString());
    }

内存图类似

2.3.1浅拷贝

class Money{
    public double  m=12.5;
}
class Person implements Cloneable{
    private String name;
    private int age;
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    Money money=new Money();

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

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

public class TestDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1=new Person("xiaohong",20);
        Person person2=(Person) person1.clone();
        System.out.println(person1.money.m);
        System.out.println(person2.money.m);
        System.out.println("========================");
        person1.money.m=100;
        System.out.println(person2.money.m);
    }
 }

我们看到了我们new一个money后,我们是我们通过person1修改了money中的值后,person也随之修改,这就验证了,直接重写clone方法就是浅拷贝!
内存图大概:

那我们如何让他深拷贝呢?

2.3.2深拷贝

我们在类中clone方法中进一步克隆,看代码:

 class Money implements Cloneable{
    public double  m=12.5;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Person implements Cloneable{
    private String name;
    private int age;
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    Money money=new Money();

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person tmp=(Person) super.clone();
        tmp.money= (Money) this.money.clone();
        return tmp;
    }
}

public class TestDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1=new Person("xiaohong",20);
        Person person2=(Person) person1.clone();
        System.out.println(person1.money.m);
        System.out.println(person2.money.m);
        System.out.println("========================");
        person1.money.m=100;
        System.out.println(person1.money.m);
        System.out.println(person2.money.m);
    }
}

也就是说我们先克隆了一个person1对象给tmp,然后再将person1中的money这个对象再克隆给tmp中的money,然后返回tmp;
这就实现了深拷贝!!!
大概内存图: