比较器，深拷贝，浅拷贝

Comparable接口

我们写一个Student类，方便以下讲解

public class Student {
    public String name;
    public int age;

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

当我们想要去比较我们自己定义的类时，发现我们无法去进行。因为他自能比较基本数据类型。

  public static void main(String[] args) {
        Student student1 = new Student("张三",20);
        Student student2 = new Student("李四",21);
        System.out.println(student1 > student2);
  }

单比较

如果我们想要比较我们自己定义的类时，那我们就要实现Comparable接口，并且重写compareTo方法。

public class Student implements Comparable<Student>{
    public String name;
    public int age;

    @Override
    public int compareTo(Student o) {
        return this.age - o.age;
    }
}

然后再通过main函数去调用compareTo方法来比较。

public static void main(String[] args) {
        Student student1 = new Student("张三",20);
        Student student2 = new Student("李四",21);
        System.out.println(student1.compareTo(student2));
}    

我们发现他只能单个比较，那我们想要多个比较该怎么办呢？

多比较

我们只需要把这些对象放到一个数组里，因为Student实现了Comparable接口，所以可以通过Array.sort()方法进行排序，完成比较。

 public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("张三",20);
        students[1] = new Student("李四",21);
        students[2] = new Student("王五",22);
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
 }

Comparator接口

Comparable接口会把方法写死，无法灵活比较。如果想灵活比较，我们可以使用Comparator接口来解决这个问题。

我们先写一个类来比较Student

public class AgeComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age - o2.age;
    }
}

然后在main函数里实例化，再把对象传到Array.sort()方法里就行了。如果想通过其他方式来比较同上。

 public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("张三",29);
        students[1] = new Student("李四",22);
        students[2] = new Student("王五",25);
        AgeComparator ageComparator = new AgeComparator();
        Arrays.sort(students,ageComparator);
        System.out.println(Arrays.toString(students));
 }

Comparable Comparator equals 比较

 public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
 }

 Comparable会把比较方法写死，无法通过其他方法比较，不够灵活。

Comparator它可以写很多方法比较，十分灵活，想用什么方法就用什么方法。

equals他是用来比较俩个对象是否相同。

拷贝

拷贝步骤如下

1. 首先要重写类中的clone()方法，由于Obiect是所有类的父类，所以可直接重写。

2. 然后clone()返回类型是Object，所以要向下转型。

3. 实现Cloneable接口，该接口是空接口，但必须实现用来表示类可以被克隆。

4. 在调用clone()方法之前，要实现throws CloneNotSupportedException异常。

public class Student implements Cloneable{
    public String name;
    public int age;

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

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

 public static void main(String[] args) throws CloneNotSupportedException{
        Student student1 = new Student("张三",25);
        Student student2 = (Student) student1.clone();
 
}

深拷贝和浅拷贝区别

二者的区别在于有多要个类拷贝，是否全不拷贝。如果把其他对象开辟的新空间拷贝过去，就是深拷贝。如果没有，就是浅拷贝。

如果想深拷贝，就要对Student类中m对象的类实行Cloneable接口，并重写clone()方法。

class Money implements Cloneable{
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    public int money = 10;
}
public class Student implements Cloneable{
    public String name;
    public int age;
    public Money m = new Money();
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Student tmp = (Student) super.clone();
        tmp.m = (Money) this.m.clone();
        return tmp;
    }
}