Java中的比较

墨蓝 2023-10-14 08:24 32阅读 0赞

> **目录**
> 
> 一、Java中比较的分类
> 
> 二、基本类型的比较
> 
> 一、==运算符
> 
> 三、引用类型的比较
> 
> 一、equals运算符
> 
> 二、基于Comparable接口类的比较
> 
>  三、自己定义比较器，实现Comparator接口
> 
> 四、总结对比三种比较

## 一、Java中比较的分类 ##

在Java中,我们一般分为两种比较类型, **基本类型**的比较和**引用类型**的比较

## 二、基本类型的比较 ##

Java有八大基本类型 分别是:

1.  整型 : byte short int long
2.  浮点型: float double
3.  字符型: char
4.  布尔类型:boolean

java中对于基本类型的比较通常使用比较运算符 == 进行比较 **==比较基本类型是比较值是否相等,比较引用类型是比较==两边的地址是否相等**

### 一、==运算符 ###

public static void main(String[] args) {
                int a=6;
                int b=6;
                System.out.println(a==b);
        
                String s=new String("hello world");
                String p=new String("hello world");
                System.out.println(s==p);
        
                String d="hello world";
                String f="hello world";
                System.out.println(d==f);
            }

![db2d3a7142c24ce090786fdc312cc9f0.png][]

> 由上图我们发现中间的结果为false ,这是因为new会新在堆中开辟一个地址,导致两个地址不一样;
> 
> 最后的结果是ture 因为d在使用完后会存入常量池中,f再使用的时候会先在常量池中寻找,寻找到了就直接使用常量池中的地址

## 三、引用类型的比较 ##

### 一、equals运算符 ###

equals()方法只能用来比较两个对象的地址是否相同，子类中往往重写了该方法，用于判断类容是否相同，比如Integer、String等

class Animal{
            public int age;
            public String name;
    
            public Animal(int age,String name){
                this.age=age;
                this.name=name;
            }
    }
    public class Main {
        public static void main(String[] args) {
            Animal dog=new Animal(3,"qiuqiu");
            Animal cat=new Animal(3,"qiuqiu");
            System.out.println(dog.equals(cat));
        }
    }

![5e38038cba10453b8a0c2aeead5b1296.png][]

我们接下来将代码进行覆写

import java.util.Objects;
    
    class Animal{
            public int age;
            public String name;
    
            public Animal(int age,String name){
                this.age=age;
                this.name=name;
            }
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Animal animal = (Animal) o;
            return age == animal.age && Objects.equals(name, animal.name);
        }
    
        @Override
        public int hashCode() {
            return Objects.hash(age, name);
        }
    }
    
    
    public class Main {
        public static void main(String[] args) {
            Animal dog=new Animal(3,"qiuqiu");
            Animal cat=new Animal(3,"qiuqiu");
            System.out.println(dog.equals(cat));
        }
    }

![d3d6e6bdaba1451388bc5b56d3a9d1d9.png][]

### 二、基于[Comparable接口][Comparable]类的比较 ###

我们接下来实现Comparable接口，重写CompareTo方法

![1de4eafacb2b44ff9b4d3684c52ef32f.png][]

> 谁调用compareTo方法谁就是this.  
> 被调用的就是compareTo里的参数o  
> 如果返回值>0 就说明主调的对象**大于**被调的对象  
> 如果返回值<0 就说明主调的对象**小于**被调的对象  
> 如果返回值=0 就说明两个对象**相等**

当然,这种方法的缺点就是不灵活,比较的方式已经固定死了,我们通常使用下面这种定义比较器的方法

### 三、自己定义比较器，实现Comparator接口 ###

方法:自己定义比较器，实现Comparator接口，重写compara方法,相比于上面的方法,对比较的类的侵入性弱

import java.util.Comparator;
    import java.util.Objects;
    
    class Animal implements Comparable<Animal> {
            public int age;
            public String name;
    
            public Animal(int age,String name){
                this.age=age;
                this.name=name;
            }
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Animal animal = (Animal) o;
            return age == animal.age && Objects.equals(name, animal.name);
        }
    
        @Override
        public int hashCode() {
            return Objects.hash(age, name);
        }
    
    
    
        @Override
        public int compareTo(Animal o) {
            return this.age - o.age;
        }
    }
    
    //姓名比较器
    class Name implements Comparator<Animal>{
    
        @Override
        public int compare(Animal o1, Animal o2) {
            return o1.name.compareTo(o2.name);
        }
    }
    //年龄比较器
    class Age implements Comparator<Animal>{
    
        @Override
        public int compare(Animal o1, Animal o2) {
            return o1.age-o2.age;
        }
    }
    
    
    public class Main {
        public static void main(String[] args) {
            
            Animal dog=new Animal(4,"wangwang");
            Animal cat=new Animal(2,"miaomiao");
            Name name = new Name();
            Age age = new Age();
    
            System.out.println(name.compare(dog,cat));
            System.out.println(age.compare(dog,cat));
        }
    }

![2ca7b30617934c968a150b5db9ea24d6.png][]

>  *  返回值< 0: 表示 o1 指向的对象小于 o2 指向的对象
>  *  返回值== 0: 表示 o1 指向的对象等于 o2 指向的对象
>  *  返回值> 0: 表示 o1 指向的对象等于 o2 指向的对象

## 四、总结对比三种比较 ##

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>覆写的方法</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>Object.equals</td> 
   <td>因为所有类都是继承自 Object 的，所以直接覆写即可，不过只能比较相等与否</td> 
  </tr> 
  <tr> 
   <td>Comparable.compareTo</td> 
   <td>要手动实现接口,代码侵入性强,不灵活</td> 
  </tr> 
  <tr> 
   <td>Comparator.compare</td> 
   <td>需要实现一个比较器对象,对比较的类的侵入性弱,对算法实现侵入性强</td> 
  </tr> 
 </tbody> 
</table>

**如有错误还请指出,欢迎阅读**

[db2d3a7142c24ce090786fdc312cc9f0.png]: https://img-blog.csdnimg.cn/db2d3a7142c24ce090786fdc312cc9f0.png
[5e38038cba10453b8a0c2aeead5b1296.png]: https://img-blog.csdnimg.cn/5e38038cba10453b8a0c2aeead5b1296.png
[d3d6e6bdaba1451388bc5b56d3a9d1d9.png]: https://img-blog.csdnimg.cn/d3d6e6bdaba1451388bc5b56d3a9d1d9.png
[Comparable]: https://so.csdn.net/so/search?q=Comparable%E6%8E%A5%E5%8F%A3&spm=1001.2101.3001.7020
[1de4eafacb2b44ff9b4d3684c52ef32f.png]: https://img-blog.csdnimg.cn/1de4eafacb2b44ff9b4d3684c52ef32f.png
[2ca7b30617934c968a150b5db9ea24d6.png]: https://img-blog.csdnimg.cn/2ca7b30617934c968a150b5db9ea24d6.png