【JavaSE】【对象比较、克隆】

清元丶

已于 2023-06-16 23:42:28 修改

阅读量57

点赞数

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

于 2023-06-11 15:06:29 首次发布

本文链接：https://blog.csdn.net/OTO233/article/details/131097746

版权

JavaSE 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

对象克隆（复制）--- Clonable 接口

对象比较

比较可以分为对基本数据类型和自定义数据类型两种比较

基本数据类型比较

对于基本数据类型的比较，因为有大小属性，可以直接进行大小比较，那么对对象（自定义类型）我们可以直接对大小针对比较吗？

class Student{
    public String name;
    public int age;

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

public class Compar {

    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("zhangsan",18);
        students[1] = new Student("lisi",12);
        students[2] = new Student("wangwu",23);

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

    }
}

针对 Student 类，进行排序操作时，不能对其包含的属性进行排序，就会出现报错；

针对对象的比较我们有三种比较方式

1、Comparable 接口

直接对自定义类型比较会出现异常，自定义类型的大小不明确，不能直接比较

需要传入的数组的每个对象都是 "可比较" 的, 需要具备 compareTo 这样的能力. 通

过重写 compareTo 方法的方式, 就可以定义比较规则.

实现 Comoarable 接口，重写 compareTo() 方法，可以比较对象
缺点：比较类型定死了，只能比较一种成员，不好更改

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

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

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

}

public class Compar {
a
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("zhangsan",18);
        students[1] = new Student("lisi",12);
        students[2] = new Student("wangwu",23);

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

    }
}

2、Comparator 接口

对于 Comparable 的比较的缺点，我们可以采用 Comparator 接口的方法对不同成员进行比较，再重新定义一个比较类，灵活的设计比较方法

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 +
                '}';
    }

}

//构造器
class NameCompare implements Comparator<Student>{

    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}
class AgeCompare implements Comparator<Student>{

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

public class Compar_To {

    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("zhangsan",18);
        students[1] = new Student("lisi",12);
        students[2] = new Student("wangwu",23);

        //定义构造器
        NameCompare nameCompare = new NameCompare();
        //
        AgeCompare ageCompare = new AgeCompare();
        //比较姓名
        Arrays.sort(students,nameCompare);
        System.out.println(Arrays.toString(students));
        System.out.println("===========================================");
        //比较年龄
        Arrays.sort(students,ageCompare);
        System.out.println(Arrays.toString(students));

    }
}

同时，Sort() 方法页支持比较器 Comparator

3、equals

在Java中，==进行比较时：

如果==左右两侧是基本类型变量，比较的是变量中值是否相同
如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同
如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认也是按照地址比较的：

Object类中的equals方法直接对比的是对象的引用地址

// Object类中的equals方法
public boolean equals(Object obj) {
  return (this == obj);  // 使用引用中的地址直接来进行比较
}

结论：比较对象中内容是否相同的时候，一定要重写equals方法。

class Person{
	//重写
    @Override
    public boolean equals(Object obj) {
        //比较的 不能是 null
        if (obj == null) {
        	return false ;
    	}
        //是 同一对象 相等
        if(this == obj) {
        	return true ;
        }
        // 不是Person类对象 不能比较
        if (!(obj instanceof Person)) {
        	return false ;
        }
    
    Person person = (Person) obj ; // 向下转型，比较属性值
    	return this.name.equals(person.name) && this.age==person.age ;
    }
}

对象克隆（复制）--- Clonable 接口

Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 "拷贝". 但是要想合法调用 clone 方法, 必须要先实现 Clonable 接口, 否则就会抛CloneNotSupportedException 异常.

如果，我们直接对一个自定义对象使用 clone() 方法

class Person implements Cloneable{
    public String name;

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

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

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

public class Clone {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person("张三");
        System.out.println("person1:"+person1);
        Person person2 = (Person) person1.clone();
        System.out.println("person2:"+person2);
        System.out.println("==========================");
        person1.name = "李四";
        System.out.println("person1:"+person1);
        System.out.println("person2:"+person2);
    }
}

得到的结果看似完美复制过来，但是如果对象中包含自定义类型会如何？

添加 自定义类型的成员 Money

class Money{
    public double money = 12.5;
}
class Person implements Cloneable{
    public String name;
    public Money mon = new Money();
    public Person(String name){
        this.name = name;
    }

    @Override
    public String toString() {
        return
                "name='" + name + '\''+" "+"money='" + mon.money + '\'';
    }

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

public class Clone {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person("张三");
        System.out.println("person1:"+person1);
        Person person2 = (Person) person1.clone();
        System.out.println("person2:"+person2);
        System.out.println("==========================");
        person1.mon.money = 55.5;
        System.out.println("person1:"+person1);
        System.out.println("person2:"+person2);
    }
}

结果出现是，在对 person1 进行对自定义类型成员修改时，person2 的数据也会跟着修改

这种问题是：

包含了自定义类型的 money，再在复制过程中，进行的是浅拷贝，就是简单的将里面的值复制类过来，但是自定义类型中存的可能是一个引用，将次引用复制就是两个对象指向的是统一地址的数据；

解决：

需要在自定义类型成员中实现克隆方法，同时在要复制的类中针对自定义类型的成员也要调用克隆方法对其克隆，这样这两个类中的自定义类型的成员就是指向不同的地址

class Money implements Cloneable{
    public double money = 12.5;
	//添加 克隆方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Person implements Cloneable{
    public String name;
    public Money mon = new Money();
    public Person(String name){
        this.name = name;
    }

    @Override
    public String toString() {
        return
                "name='" + name + '\''+" "+"money='" + mon.money + '\'';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        //只是 克隆 Person 对象
        Person person = (Person) super.clone();
        //克隆 成员变量 mon
        person.mon = (Money) this.mon.clone();
        return person;
    }
}

public class Clone {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person("张三");
        System.out.println("person1:"+person1);
        Person person2 = (Person) person1.clone();
        System.out.println("person2:"+person2);
        System.out.println("==========================");
        person1.mon.money = 55.5;
        System.out.println("person1:"+person1);
        System.out.println("person2:"+person2);
    }
}

清元丶

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【JavaSE】【对象比较、克隆】

目录对象比较基本数据类型比较 1、Comparable 接口2、Comparator 接口3、equals对象克隆（复制）--- Clonable 接口比较可以分为对基本数据类型和自定义数据类型两种比较针对对象的比较我们有三种比较方式同时，Sort() 方法页支持比较器 Comparator Object类中的equals方法直接对比的是对象的引用地址结论：比较对象中内容是否相同的时候，一定要重写equals方法。对象克隆（复制）---
复制链接

扫一扫

专栏目录