初识java——javaSE （6）接口的实现——比较器与深拷贝，浅拷贝

news2025/3/16 22:52:03

文章目录

  • 前言
  • 一 比较器
    • 1.1 关于两个对象的比较
    • 1.2 Comparable接口：
    • 1.3 Arrays.sort方法的实现
    • 1.4 比较器的实现
      • Comparator接口
  • 二 深拷贝与浅拷贝
    • 2.1 浅拷贝：
      • Cloneable接口：
      • clone方法：
      • 实现拷贝：
      • 浅拷贝：
    • 2.2 深拷贝：

前言

上一篇博客并没有将接口的内容阐述完毕，这篇博客继续阐述！

一 比较器

1.1 关于两个对象的比较

在比较单个基本数据类型时，我们可以通过关系运算符进行比较。

 public class Test {
   
        public static void main(String[] args) {
            int age1 = 10;
            int age2 = 8;
            System.out.println(age1 > age2);
           }

在这里插入图片描述

但是当比较对象等引用数据类型时，便不能仅仅通过关系运算符进行比较了。

class Student {
    String name;
    int age;

    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }
  }
     public class Test {
               public static void main(String[] args) {

            Student student1 = new Student(10,"张三");
            Student student2 = new Student(12,"李四");
            System.out.println(student1>student2);

     }
   
    }

在这里插入图片描述

要进行对象间的比较，需要确定进行比较的规则是什么，比较哪一个属性。

1.2 Comparable接口：

Comparable接口中的compareTo 方法用于进行对象间属性的比较。

在这里插入图片描述
compareTo是一个抽象方法，我们需要重写：

//创建一个Student类，实现Comparable接口
class Student implements Comparable<Student> {
    String name;
    int age;

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
//重写compareTo方法
    @Override
    public int compareTo(Student o) {
        //比较年龄：

        if(this.age == o.age){
            return 0;
        }else if(this.age>o.age){
            return 1;
        }else {
            return -1;
        }
    }
        //比较姓名
      //  return this.name.compareTo(o.name);
    }

    public class Test {
  
        public static void main(String[] args) {

            Student student1 = new Student(10,"张三");
            Student student2 = new Student(12,"李四");
            System.out.println(student1.compareTo(student2));

在这里插入图片描述
结果为-1 ,表明student1的年龄比student2的年龄小。
代码分析：
Student类实现了Comparable接口，
<>是泛型的标记，以后会阐述到，比较那个类，就将类名填写在<>中！

对象间的比较本质上依然是对象属性之间的比较。

1.3 Arrays.sort方法的实现

如果创建一个对象数组，使得数组中的这些对象按照某种规则进行排序
则可以使用Array.sort方法

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

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

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


    @Override
    public int compareTo(Student o) {
        //比较年龄：

        if(this.age == o.age){
            return 0;
        }else if(this.age>o.age){
            return 1;
        }else {
            return -1;
        }
    }
        //比较姓名
      //  return this.name.compareTo(o.name);
    }

  public class Test {
  public static void main(String[] args) {
            Student[] arr1 = new Student[3];
            arr1[0] = new Student(10, "王五");
            arr1[1] = new Student(8, "李四");
            arr1[2] = new Student(9, "张三");
                Student[] arr1 = {student1,student2,student3};
            System.out.println("排序前："+Arrays.toString(arr1));
            
            Arrays.sort(arr1);
            System.out.println("排序后："+Arrays.toString(arr1));
          
     }
}

在这里插入图片描述
排序后，年龄从小到大，依次递增。

如果不实现Comparable接口，会怎么样呢？
在这里插入图片描述
在这里插入图片描述
结果表明Student类型，不能转换成Comparable类型，这是怎么回事，我们调用Arrays.sort方法进行排序，与转换类型有什么关系？

这里我们需要手动实现一下Arrays.sort方法

 public  static  void mysort(Comparable[] comparables){
        // 用接口数组接收实现接口的数组   采用冒号排序的方式
        //比较的趟数！
        for (int i = 0;i<comparables.length-1 ;i++){
              for (int j = 0; j<comparables.length - 1-i;j++){
              
                  if(comparables[j].compareTo(comparables[j+1])>0){
                       //如果数组前面元素的值大于数组后面元素的值，则交换引用的值,这是升序
                      Comparable tmp  = comparables[j];
                      comparables[j]  = comparables[j+1];
                      comparables[j+1] = tmp;
                  }
              }

        }
    }

代码分析： 问题就在于 if(comparables[j].compareTo(comparables[j+1])>0) 这条语句
我们通过接口类型数组来接收实现了接口的数组，并且对compareTo方法进行调用！

在上个例子中，因为没有Student没有实现Comparable接口，所以会发生Student类型无法发生向上转型成Comparable接口类型的情况。

调用自己实现的mysort方法：

class Student implements Comparable<Student> {
    String name;
    int age;
    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    public int compareTo(Student o) {
        //比较年龄：

        if(this.age == o.age){
            return 0;
        }else if(this.age>o.age){
            return 1;
        }else {
            return -1;
        }
    }
        //比较姓名
      //  return this.name.compareTo(o.name);
    }
    public class Test {


  public static void main(String[] args) {

       
            Student[] arr1 = new Student[3];


            arr1[0] = new Student(10, "王五");
            arr1[1] = new Student(8, "李四");
            arr1[2] = new Student(9, "张三");
         
            System.out.println("排序前：" + Arrays.toString(arr1));
           
              mysort(arr1);
            System.out.println("排序后：" + Arrays.toString(arr1));
           

        }
    }

在这里插入图片描述

1.4 比较器的实现

在上面实现compareTo方法时，我们只能比较某一固定的属性，比如年龄或者名字，
这比较有局限性，总不能当需要比较某一属性时，再去修改类的实现。

解决方案：当需要比较某一属性时，就调用相关的类！

Comparator接口

在这里插入图片描述
如图所示：Comparator接口中有一个compare抽象方法。
我们可以创建不同的类来实现此接口，当需要比较不同的属性值时，调用不同的类：

举例:

//在单独一个java文件中
package demo1;

import java.util.Comparator;
//创建一个NameComparator类，实现Comparator接口
public class NameComparator implements Comparator<Student> {
    @Override
    //实现接口中的抽象方法，用于进行名字之间的比较！
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}

o1.name之所以可以引用compareTo方法是因为String类中重写了compareTo方法：
在这里插入图片描述

//在另一个java文件中
package demo1;

import java.util.Comparator;
//实现Comparator接口
public class AgeComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {

        return o1.age - o2.age;
    }
}

package demo1;


import java.util.Arrays;
import java.util.Comparator;

//接口的应用！
// 比较两个对象的尝试！
// 实现关于comparable接口！
class Student implements Comparable<Student> {
    String name;
    int age;

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

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


    public int compareTo(Student o) {
        //比较年龄：

        if(this.age == o.age){
            return 0;
        }else if(this.age>o.age){
            return 1;
        }else {
            return -1;
        }
    }
        //比较姓名
      //  return this.name.compareTo(o.name);
    }
    public class Test {
  
      public static void main(String[] args) {
            Student[] arr1 = new Student[3];
            arr1[0] = new Student(10, "王五");
            arr1[1] = new Student(8, "李四");
            arr1[2] = new Student(9, "张三");
       
       System.out.println("排序前：" + Arrays.toString(arr1));
            //创建一个NameComparator对象。
    NameComparator nameComparator   =  new NameComparator();
            //进行名字间的比较！
            //Arrays.sort方法可以接收第二个参数！
            Arrays.sort(arr1,nameComparator);
       
           
     System.out.println("排序后：" + Arrays.toString(arr1));
           
        }
    }

这是按照姓名排序的结果：
在这里插入图片描述

按照年龄排序，则调用AgeComparator类：

     System.out.println("排序前：" + Arrays.toString(arr1));
     AgeComparator ageComparator = new AgeComparator();
            //根据年龄进行比较！
            Arrays.sort(arr1,ageComparator);
         System.out.println("排序后："+Arrays.toString(arr1));

排序后，年龄从小到大！
在这里插入图片描述

我们通过创建不同的实现Comparator的类，并实现抽象方法compare,
当需要比较某一属性时，即调用某一属性对应类进行比较，这就是比较器的思想与实现！

二 深拷贝与浅拷贝

2.1 浅拷贝：

 所谓拷贝即将一个对象复制一份，由另一个引用指向新复制出的对象。

Cloneable接口：

要进行拷贝的类，需要先实现Cloneable接口.
在这里插入图片描述

Cloneable接口是一个空接口，代表着实现此接口的类可以被拷贝！

clone方法：

clone方法是Object类中用来拷贝对象的方法。
在这里插入图片描述

此方法被Native修饰，说明它是由C/C++等其他编程语言实现，不能查看其具体实现。

实现拷贝：

package demo1;

public class Person implements Cloneable{   //实现空接口的类，代表可以拷贝
              String name;
              int age ;

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

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


package demo1;
// 浅拷贝

public class Test {
    public static void main(String[] args) {
      Person person1 = new Person("张三",10);
      Person person2 =  person1.clone();
    }
}

（1）此时编译器报警告：
在这里插入图片描述

尽管clone方法的访问权限是protected且Test也是Object的子类，但是当person1调用clone方法时，
是在Person类的外部，所以报错。

解决这个问题，我们需要在子类中重写clone方法：

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

(2) 此时编译器又报警告：

在这里插入图片描述
这是异常的问题，以后会阐述到，解决这个问题，在main方法后，加上一条语句即可：

在这里插入图片描述
（3）编译器又报警告的原因是：
方法的返回值类型为Object类型，我们需要将其强制为Person类型。

package demo1;
// 浅拷贝

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

    }
}

在这里插入图片描述

此刻，内存中情况如下：
在这里插入图片描述

浅拷贝：

拷贝的情况讲完了，那什么是浅拷贝呢？
当对象中有对象的创建时，此时只拷贝外部的对象，而不拷贝内部的对象，称为浅拷贝！
举例：

package demo1;
//创建一个Person类，实现接口
public class Person implements Cloneable{   //实现空接口的类，代表可以拷贝
              String name;
              int age ;

              Money money1 = new Money(10);

    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();
    }
}


package demo1;
//创建一个Money类
public class Money {
    int moneycount ;

    public Money(int moneycount) {
        this.moneycount = moneycount;
    }
}


package demo1;
// 浅拷贝

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException{
      Person person1 = new Person("张三",10);
      Person person2 = (Person) person1.clone();
        System.out.println("修改前："+person1.money1.moneycount);
        System.out.println("修改前："+person2.money1.moneycount);
//仅仅修改person2中的money对象的值，会不会改变person1中的值？
        person2.money1.moneycount = 20;
        System.out.println("修改后："+person1.money1.moneycount);
        System.out.println("修改后："+person2.money1.moneycount);

    }
}

在这里插入图片描述

在内存中情况：
在这里插入图片描述

这种未将对象 中的对象 拷贝的不彻底拷贝，我们称为浅拷贝！

2.2 深拷贝：

深拷贝也就是将对象中的对象也进行拷贝， 
这需要对Person类中的clone方法进行重写：
并且对Money类按照Person类中的格式进行重写编写

代码：

//Person类
package demo1;

public class Person implements Cloneable{   //实现空接口的类，代表可以拷贝
              String name;
              int age ;

              Money money1 = new Money(10);

    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 {
        Person tmp = (Person) super.clone();    //谁调用了super方法，不需要this指定对象。
        //对于对象中的对象也进行拷贝！
        tmp.money1 = (Money) this.money1.clone();
        return tmp;



    }
}


//Money类
package demo1;

public class Money implements Cloneable {
    int moneycount ;

    public Money(int moneycount) {
        this.moneycount = moneycount;
    }
//也重写clone方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

//测试类
package demo1;
// 浅拷贝

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException{
      Person person1 = new Person("张三",10);
      Person person2 = (Person) person1.clone();
        System.out.println("修改前："+person1.money1.moneycount);
        System.out.println("修改前："+person2.money1.moneycount);

        person2.money1.moneycount = 20;
        System.out.println("修改后："+person1.money1.moneycount);
        System.out.println("修改后："+person2.money1.moneycount);

    }

在这里插入图片描述
结果表明，此时深拷贝成功，修改person2中的money值，不会改变person1中的值！

在内存中的展示：
在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1694863.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

2024年5月22日 (周三) 叶子游戏新闻

2024年5月22日 (周三) 叶子游戏新闻

《奇星协力》Steam抢先体验开启 求生城市建造Leikir Studio工作室开发的一款求生城市建造新游《奇星协力》Steam抢先体验开启&#xff0c;限时九折优惠&#xff0c;本作支持中文&#xff0c;感兴趣的玩家可以关注下了。 《原神》预告4.7版本前瞻特别节目 5月24日播出5月22日&am…
阅读更多...
Opencompass模型评测教程

Opencompass模型评测教程

模型评测 模型评测非常关键&#xff0c;目前主流的方法主要可以概括为主观评测和客观评测&#xff0c;主观评测又可以分为两种形式&#xff1a;人工判断或者和模型竞技场。客观评测一般采用评测数据集的形式进行模型评测。本教程使用Opencompass工具进行对Internlm2-7b模型进行…
阅读更多...
分布式版本控制工具 git

分布式版本控制工具 git

git 是什么 分布式版本控制工具。github 是代码托管平台。 git 有什么用 保存文件的所有修改记录。使用版本号&#xff08;sha1 哈希值&#xff09; 进行区分。随时可浏览历史版本记录。可还原到历史指定版本。对比不同版本的文件差异。 为什么要使用 git 多人协作开发一个大…
阅读更多...
达梦数据库创建根据日期按月自动分区表

达梦数据库创建根据日期按月自动分区表

达梦数据库创建根据日期自动分区表 概念 达梦数据交换平台(简称DMETL)是在总结了众多大数据项目经验和需求并结合最新大数据发展趋势和技术的基础上&#xff0c;自主研发的通用的大数据处理与集成平台。 DMETL创新地将传统的ETL工具&#xff08;Extract、Transform、Loading…
阅读更多...
微软密谋超级AI大模型！LangChain带你轻松玩转大模型开发

微软密谋超级AI大模型！LangChain带你轻松玩转大模型开发

此前&#xff0c;据相关媒体报道&#xff0c;微软正在研发一款名为MAI-1的最新AI大模型&#xff0c;其参数规模或将达5000亿以上&#xff0c;远超此前微软推出的相关开源模型&#xff0c;其性能或能与谷歌的Gemini 1.5、Anthropic的Claude 3和OpenAI的GPT-4等知名大模型相匹敌。…
阅读更多...
3D 生成重建014-Bidiff使用二维和三维先验的双向扩散

3D 生成重建014-Bidiff使用二维和三维先验的双向扩散

3D 生成重建014-Bidiff使用二维和三维先验的双向扩散 文章目录 0 论文工作1 论文方法2 效果 0 论文工作 大多数三维生成研究集中在将二维基础模型向上投影到三维空间中&#xff0c;要么通过最小化二维评分蒸馏采样&#xff08;SDS&#xff09;损失&#xff0c;要么通过对多视图…
阅读更多...
C++ 常用UI库

C++ 常用UI库

AWTK github gitee doc scons 类似RT-Thread element github C Cross platfrom C GUI libraries&#xff0c;QT可替代方案。调试包 SDL GUI cegui 创作不易&#xff0c; 小小的支持一下吧&#xff01;
阅读更多...
记录一次Docker部署FastApi项目

记录一次Docker部署FastApi项目

流程 windows需安装Docker for desktop 已登录docker账号 编写Dockerfile文件 # 使用Python作为基础镜像, slim-buster是一个轻量级的镜像, 适合生产环境使用 FROM python:3.9-slim-buster # 设置工作目录 WORKDIR /app # 复制应用代码到容器中 COPY . . # 安装依赖项 RUN…
阅读更多...
Ollydbg动态分析MessageBoxA输出hellow world

Ollydbg动态分析MessageBoxA输出hellow world

一、目的 找到main函数找到调用的MessageBoxA函数 测试源码 #include <iostream> #include <windows.h>int main() {MessageBoxA(NULL, "Hellow World", "Title", MB_OK);return 1; }二、快捷键 指令快捷键说明RestartCtrlF2重新开始调试S…
阅读更多...
C++与Android处理16进制大端/小端数据实例(二百七十六)

C++与Android处理16进制大端/小端数据实例(二百七十六)

简介&#xff1a; CSDN博客专家&#xff0c;专注Android/Linux系统&#xff0c;分享多mic语音方案、音视频、编解码等技术&#xff0c;与大家一起成长&#xff01; 优质专栏&#xff1a;Audio工程师进阶系列【原创干货持续更新中……】&#x1f680; 优质专栏&#xff1a;多媒…
阅读更多...
微服务中使用Maven BOM来管理你的版本依赖

微服务中使用Maven BOM来管理你的版本依赖

摘要: 原创出处 sf.gg/a/1190000021198564 「飘渺Jam」欢迎转载&#xff0c;保留摘要&#xff0c;谢谢&#xff01; 为什么要使用BOM? 如何定义BOM? 项目使用方法? BOM&#xff08;Bill of Materials&#xff09;是由Maven提供的功能,它通过定义一整套相互兼容的jar包版…
阅读更多...
使用docker commit创建新镜像

使用docker commit创建新镜像

前言 我们知道&#xff0c;从docker-hub上拉取的镜像所创建的容器是最小版本的&#xff0c;比如ubuntu内部是没有vim编辑器的&#xff0c;我们需要自己手动安装&#xff0c;但是当我们安装后假如有人把我们的容器误删了&#xff0c;那么我们再次根据原始镜像创建的容器就没有了…
阅读更多...
Windows安装VMware(Broadcom)

Windows安装VMware(Broadcom)

1.安装前提 1.检查BIOS中是否开启了虚拟化技术。1.1 打开任务管理器&#xff0c;查看性能&#xff0c;CPU部分&#xff0c;虚拟化处于“已启用”状态。1.2 如果没有开启&#xff0c;则需要进入BIOS系统&#xff0c;将 Intel Virtualization Technology改为Enalble。2.下载VMwa…
阅读更多...
小阿轩yx-PXE 高效批量网络装机

小阿轩yx-PXE 高效批量网络装机

小阿轩yx-PXE 高效批量网络装机 部署PXE远程安装服务 PXE 概述 PXE&#xff08;Preboot eXcution Environment&#xff0c;预启动执行环境&#xff0c;在操作系统之前运行&#xff09;技术的网络装机方法&#xff0c;是由 Intel 公司开发的网络引导技术&#xff0c;工作在 C…
阅读更多...
二进制中1的个数c++

二进制中1的个数c++

题目描述 计算鸭给定一个十进制非负整数 NN&#xff0c;求其对应 22 进制数中 11 的个数。 输入 输入包含一行&#xff0c;包含一个非负整数 NN。(N < 10^9) 输出 输出一行&#xff0c;包含一个整数&#xff0c;表示 NN 的 22 进制表示中 11 的个数。 样例输入 100 …
阅读更多...
IS-IS链路状态数据库

IS-IS链路状态数据库

原理概述 一个OSPF链路状态数据库是若干条LSA的集合。与此相似&#xff0c;一个IS-IS链路状态数据库是由若干条LSP的集合。与OSPF链路状态数据库不同&#xff0c;IS-IS链路状态数据库有Level-1和Level-2之分。 在IS-IS协议中&#xff0c;每一条LSA都有一条剩余生存时间、一个…
阅读更多...
『USB3.0Cypress』FPGA开发(3)GPIF II短包零包时序分析

『USB3.0Cypress』FPGA开发(3)GPIF II短包零包时序分析

文章目录 1.时序参数2.FX3_PCLK3.短包和零包3.1短包时序3.2零包ZLP时序 4.传送门 1.时序参数 AN65974文档中明确了操作GPIF II接口时的时序参数&#xff0c;上一篇文章中给出了读写时序图&#xff0c;本篇第二节给出ZLP写周期时序&#xff0c;这里说明相关的时序参数。应该注意…
阅读更多...
校园二手书交易|基于SprinBoot+vue的校园二手书交易管理系统(源码+数据库+文档)

校园二手书交易|基于SprinBoot+vue的校园二手书交易管理系统(源码+数据库+文档)

校园二手书交易管理系统 目录 基于SprinBootvue的校园二手书交易管理系统 一、前言 二、系统设计 三、系统功能设计 1系统功能模块 2管理员功能模块 3 卖家用户功能模块 4 用户功能模块 四、数据库设计 五、核心代码 六、论文参考 七、最新计算机毕设选题推荐 八…
阅读更多...
WPF之容器标签之Canvas布局标签

WPF之容器标签之Canvas布局标签

Canvas: 定义一个区域&#xff0c;可在其中使用相对于 Canvas 区域的坐标以显式方式来定位子元素。 实例 可以在子标签使用Canvas属性设置定位 <Canvas Width"500" Height"300"><StackPanel Width"100" Height"100"Backgro…
阅读更多...
基于51单片机的火灾检测设计（仿真+程序+原理图+论文报告+讲解视频）

基于51单片机的火灾检测设计（仿真+程序+原理图+论文报告+讲解视频）

基于51单片机的火灾检测设计 基于51单片机的火灾检测设计&#xff08;仿真程序原理图论文报告&#xff09;功能要求仿真图&#xff1a;原理图&#xff1a;源程序&#xff1a;论文/报告&#xff1a;资料清单&#xff1a; 基于51单片机的火灾检测设计&#xff08;仿真程序原理图论…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023