目录
对象比较
比较 可以分为对 基本数据类型 和 自定义数据类型 两种比较
基本数据类型比较
对于基本数据类型的比较,因为有大小属性,可以直接进行大小比较,那么对 对象(自定义类型)我们可以直接对大小针对比较吗?
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);
}
}