三种常用接口

牧..

已于 2022-08-11 17:42:47 修改

阅读量886

点赞数 21

分类专栏： java 文章标签： java 算法数据结构

于 2022-08-11 16:51:04 首次发布

本文链接：https://blog.csdn.net/mu_tong_/article/details/126288028

版权

java 专栏收录该内容

16 篇文章 2 订阅

订阅专栏

文章目录

三种常用接口
1.Comparable 接口
2. Comparator 比较器
3.Cloneable 接口
- 深浅拷贝

三种常用接口

1.Comparable

2.Comparator 比较器

3.Cloneable

1.Comparable 接口

前引 :

在这里插入图片描述

熟悉吗? 我想大家应该非常熟悉 .

对于数组我们能通过 Arrays.sort() 来进行排序数组 ( 数组内部是普通数据类型).

如果我们使用 Arrays.sort() 排序的数组内部是对象(对象的地址 )呢?

这里能否进行排序 .

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

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

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}
public class Main {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0]  = new Student(12,"小红",98.9);
        students[1]  = new Student(6, "小黄",18.9);
        students[2]  = new Student(18,"小蓝",88.9);
        System.out.println(Arrays.toString(students));

        Arrays.sort(students);

        System.out.println(Arrays.toString(students));

    }
}

在这里插入图片描述

尝试之后会发现报错了 ,为啥呢 ?

想一想 . 我们两个普通的整数比较是不是可以直接比较如 : 2 > 1 , 这种大小关系就非常明确 , 如果是两个对象呢 ?

如: 上面的学生类 , 创建出两个对象学生 1 和学生 2 , 他们拥有的属性有年龄 , 姓名, 成绩 , 此时比较学生 1 和学生 2 , 我们的 sort 就会犯了迷糊 , 是按照年龄比较 , 还是按照成绩比较 , 还是按照姓名比较呢 (字母的 ASCII 值 )?

所以这里我们就报错了 , 这里就需要我们自己指定比较规则 .

下面让我们进入 sort 的源码来了解一下.

第一步 : 通过 Ctrl 加鼠标左键进入 sort 的源码 . 然后进入 legacyMergeSort方法.

在这里插入图片描述

第二步进入 mergeSort 方法中

在这里插入图片描述

此时你就能看到我们要学的 Comparable 和 compareTo

在这里插入图片描述

这段代码的意思 : 就是数组每个对象调用 comparable 进行比较 , 通过 compareTo 的比较规则 ,进行比较 .

(Comparable 可以让实现它的类的对象进行比较，具体的比较规则是按照 compareTo 方法中的规则进行)

知道了原理 :

下面我们就来尝试告诉我们的sort 比较规则来对我们的学生类进行比较 .

第一步: 实现 comparable 接口 .

comparable 是一个接口 , 我们使用 implements来实现我们的 comparable 接口 .

在这里插入图片描述

此时你会看到一个这是一个泛型 ,T 是我们的类名 , 泛型将在数据结构中讲到这里直接使用即可 .

在这里插入图片描述

当你实现完接口后发现报错了, 下面继续进入 Comparable 接口中 ,

在这里插入图片描述

你能发现这里会有一个方法 compareTo , 之前学过接口在接口中的方法默认是被public abstract修饰的是抽象方法, 需要我们重写.

在这里插入图片描述

下面就来按照年龄来比较

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

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

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

    @Override
    public int compareTo(Student o) {
        return this.age - o.age;
    }
}
public class Main {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0]  = new Student(12,"小红",98.9);
        students[1]  = new Student(6, "小黄",18.9);
        students[2]  = new Student(18,"小蓝",88.9);
        System.out.println(Arrays.toString(students));

        Arrays.sort(students);

        System.out.println(Arrays.toString(students));

    }

在这里插入图片描述

此时就按照年里进行了比较 ,

在这里插入图片描述

这里稍微讲解一下这个 this.age - o.age this 我们学过是调用当前对象 , o 是传入的对象, 这里就是通过当前对象的年龄减去传入对象的年龄

如果当前对象应排在参数对象之前, 返回小于 0 的数字;

如果当前对象应排在参数对象之后, 返回大于 0 的数字;

如果当前对象和参数对象不分先后, 返回 0;

图解:

在这里插入图片描述

同样我们也可完成降序只需要更改一下比较规则即可 .

在这里插入图片描述

此时我们就完成了降序操作.

这里就得出结论 :如果我们想要对自定义的数据类型，进行大小的比较需要实现可以比较的接口Comparable。

知道了Coparable 下面来学习一下 Comparator 比较器 .

2. Comparator 比较器

还是上面的这个代码

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

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

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

    @Override
    public int compareTo(Student o) {
        //升序
//        return this.age - o.age;
        // 降序
        return o.age - this.age;
    }
}
public class Main {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0]  = new Student(12,"小红",98.9);
        students[1]  = new Student(6, "小黄",18.9);
        students[2]  = new Student(18,"小蓝",88.9);
        System.out.println(Arrays.toString(students));

        Arrays.sort(students);

        System.out.println(Arrays.toString(students));

    }
}

我们上面是按照年龄比较的,如果这个逻辑执行了几个月, 有很多用户在使用 , 此时我们觉得按照年龄比较有点不妥 ,这里就改为按照成绩比较 , 此时就去改代码 .

在这里插入图片描述

但你有没有想过 , 在这几个月的时间里 , 有很多用户使用这个规则进行比较 , 那么此时就会出现问题 .

另外我们的代码也可能会因为这个规则的改变而出现很多问题 .

这里就推出来了 Comparator 这个接口来解决上面的方法

所以这里我们就来学习一下我们的 Comparator 这个接口 (这个接口也称比较器 )

1.创建一个比较器,实现我们的 Comparator 接口

在这里插入图片描述

2.重写我们的 compare 比较方法.

在这里插入图片描述

在这里插入图片描述

补充 :

为啥 Comparator 这个接口有那么多方法只重写了 compare 方法就不会报错了 ?

在这里插入图片描述

这里我们在接口中讲到过 , 如果在接口中方法是被 default 或 static 修饰是可以不重写的 , 但 equals 既没有被 default 也没有被

static 修饰同样也不需要重写是为什么呢?

在这里插入图片描述

这里是因为所有类默认继承Object，所以该类已有了Object的equals方法，相当于重写了equals方法。

下面继续 .

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

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

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


    //创建 比较器 
class AagComparator implements Comparator<Student>{

    @Override
    public int compare(Student o1, Student o2) {
        return o1.age - o2.age;
    }
}

public class Main {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student(12, "小红", 98.9);
        students[1] = new Student(6, "小黄", 18.9);
        students[2] = new Student(18, "小蓝", 88.9);
        System.out.println(Arrays.toString(students));

        // 实例化 比较器 
        AagComparator aagComparator = new AagComparator();
        // 传入 比较器  
        Arrays.sort(students,aagComparator);

        System.out.println(Arrays.toString(students));

    }
}

在这里插入图片描述

这里就通过比较器按照我们的年龄排序 .

下面我们还能按照成绩 .
在这里插入图片描述

下面我们按照姓名来排序

当你按照上面的思路你会发现报错了 , 我只能说小伙子太年轻了.

在这里插入图片描述

为啥说太年轻了呢 ?

想一想我们的 name是不是 String 类型 , 此时 name 就是引用 ,里面存放的地址 , 你咋能通过地址相减来比较大小呢 ?

此时就有同学就会问了不能相减那么要咋做呢?

很简单我们看看 String 的源码 . 去里面找找答案 .

当你进入 String 的源码中能发线我们的 String 也重写了 compareTo方法, 那么直接调用这个方法就能完成我们的比较了 ,是不是非常方便 .

在这里插入图片描述

下面就来演示一下 : 在这里插入图片描述

这里我们就学完了 Comparable 接口和 Comparator 接口 , 下面我们就来找一下两者的区别 .

Comparable 和 Comparator 都是用来实现元素排序的，它们二者的区别如下：

Comparable 是“比较”的意思，而 Comparator 是“比较器”的意思；
Comparable 是通过重写 compareTo 方法实现排序的，而 Comparator 是通过重写 compare 方法实现排序的；
Comparable 必须由自定义类内部实现排序方法，而 Comparator 是外部定义并实现排序的。

所以用一句话总结二者的区别：``Comparable可以看作是“对内”进行排序接口，而Comparator` 是“对外”进行排序的接口。

简单来说： Comparable 对类的侵入性高，一旦写好比较规则，就不能轻易改变。

而 Cinoarator 对类的侵入性低，写好后，传入比较器来进行比较即可，如果对这个比较规则不满意，也能重新写一个比较器来比较。

下面来看一下我们常用接口的第三个 Cloneable 接口

3.Cloneable 接口

这个接口主要用来对我们的对象进行克隆的，下面就来学习一下。

在之前我们学过一个方法为 clone(), 是对数组进行克隆，

在这里插入图片描述

那么我们能不能使用 clone() 这个方法对自定义数据类型进行克隆呢？

下面就来尝试一下。

1.创建一个 Person 类，在 main 创建对象

class Person {
    public String name;
    public int age;

    public void eat() {
        System.out.println(name + "嗷嗷猛 炫");
    }
}

public class Test {

    public static void main(String[] args) {
        Person person1 = new Person();
    }
}

2.克隆

在这里插入图片描述

可以看到划红线了这里我们就进入这个 clone() 方法的源码看看，

刚进来：我们观察到这个方法的返回类型是 Objct 的（注意：Object 是所有类的父类），那么这里我们就需要将这个返回值转为我们的 Person 类。

在这里插入图片描述

此时还是报错了。

在这里插入图片描述

其实最根本的原因是一个对象要克隆要产生一个副本这个引用，引用的对象是要可克隆的（引用的对象要实现Cloneable接口）

实现 Cloneable 接口

下面我们就来实现我们的 Cloneable 接口

在这里插入图片描述

当我们实现了 Cloneable接口后，发现还是不能完成我们的克隆，是不是很难受，搞这么多还是不能用搞么呀。

那么我们就进入 Cloneable 的源码来找一下答案。

在这里插入图片描述

这里我们点进 Cloneable 发现它是一个空接口，

空接口有啥作用 -》标志接口 -》代表当前这个类是可以被克隆的。

这个地方我们需要重写克隆方法然后申明一个异常发现 clone 就可以使用了

另外：我们将鼠标放在报错的地方，会出现下面的内容，

在这里插入图片描述

这里他告诉我们需要抛出一个异常（注意：异常会在后面学到，这里看看即可）

那么我们就来重写我们的克隆方法，并声明异常。

1.重写克隆方法

在这里插入图片描述

2.可以看到虽然重写了克隆方法，但是还是报错了，这里就需要我们抛出异常。

第一种通过 throw 将异常抛出

在这里插入图片描述

这里我们有两种处理异常的方法，一种就是上面将异常抛出来，让 JVM 帮忙处理（如果在方法中抛出，此时会先让 main函数处理，main 处理不了，最后会抛给 JVM 来帮我们处理）、

第二种处理异常通过 try - catch 来包裹异常。

在这里插入图片描述

上面这些了解就好，这样我们就成功的解决了我们 clone()报错；

下面就来使用

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

    public void eat() {
        System.out.println(name + "嗷嗷猛 炫");
    }

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

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

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person();
        Person person2 = (Person) person1.clone();
        System.out.println(person1);
        System.out.println(person2);
    }
}

在这里插入图片描述

这里就成功将 person1 个克隆出来了。

下面就来看看他的内存分布图：

在这里插入图片描述

此时就会有一个问题：如果我们对克隆出来的副本来说，将原来的age 改成 99 会影响这个拷贝出来的 age 值吗？

演示：

在这里插入图片描述

可以发现是不会受到影响的，这里就又回到了我们的深浅拷贝，关于深浅拷贝在数组那篇文章就简单过了一遍，这里我们再来巩固一下。

深拷贝和浅拷贝

无论是深拷贝，还是浅拷贝，都是是认为实现的一个方式。

深拷贝：拷贝完成后通过一个引用来修改拷贝的数组，原来的数组不会受影响就为深拷贝

浅拷贝：拷贝完成后通过一个引用来修改拷贝的数组，原来的数组一同被修改就为浅拷贝

决定是深拷贝，还是浅拷贝不是方法的用途，是代码的实现。也就是人为的实现。

上面的程序，就是一个深拷贝

深浅拷贝

这里我们在来定义一个类 money (钱) ，钱这个类，在 Person(人) 这个类中实例化。

判断当前对 money 这个对象的拷贝是深拷贝还是浅拷贝。

import java.util.Arrays;
class  Money{
    public double m;
}
class Person implements Cloneable {

    Money money = new Money();
    public String name;
    public int age;

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

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

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person();
        Person person2 = (Person) person1.clone();
    }
}