Java中的比较

约定不等于承诺〃 2024-03-27 15:17 0阅读 0赞

**目录**

1.基本类型

1.1分类

1.2比较

2.引用类型

2.1分类

2.2比较

2.2.1 覆写基类的equals

2.2.2基于Comparble接口类的比较

2.2.3基于比较器比较

2.3方法的对比

--------------------

在Java中，数据类型分为基本数据类型和引用数据类型，对于比较而言，两个不同的类型，比较的方法也不相同。

## 1.基本类型 ##

### 1.1分类 ###

整型：byte , short , int , long

浮点型:float , double

字符型:char

布尔型:boolean

### 1.2比较 ###

在Java中，基本类型的对象可以直接比较大小。

public static void main(String[] args) {
            int a=10;
            int b=5;
            System.out.println(a>b);
            System.out.println(a<b);
            System.out.println(a==b);
            boolean c=true;
            boolean d=false;
            System.out.println(c==d);
            System.out.println(c!=d);
        }

## 2.引用类型 ##

### 2.1分类 ###

类：class

接口:interface

数组:array

### 2.2比较 ###

#### 2.2.1 覆写基类的equals ####

1.覆写Object类的equals方法：

public class Course {
        private String name;
        private int score;
    
        public Course(String name, int age) {
            this.name=name;
            this.score=score;
        }
    
        @Override
        public String toString() {
            return "course{" +
                    "name='" + name + '\'' +
                    ", score=" + score +
                    '}';
        }
    
        //如果要比较两个course对象是否相等，就需要覆写Object类提供的equals方法
        @Override
        public boolean equals(Object o){
            // 自己和自己比较
            if(this == o){
                return true;
            }
            //传入的对象为空或者不是course类型的对象
            if(o==null || !(o instanceof Course)){
                return false;
            }
            //此时o一定不为空且是course对象，脱掉o的外套
            Course cou=(Course) o;
            return this.name.equals(cou.name);
        }
    }

2.测试：

![20003444c5af4e628431c05833419d6c.png][]

3.总结：

a.指向同一个对象，返回true

b.传入为空或者传入的类型不是该类型，返回false

c.覆写基类equals只能比较是否相同，不能比较大于，小于。

#### 2.2.2基于Comparble接口类的比较 ####

1.Comparble是JDK提供的泛型的比较接口类

2.Compareble是java.lang中的接口类

3.compareTo方法：

返回值:

< 0: 表示 this 指向的对象小于 o 指向的对象

== 0: 表示 this 指向的对象等于 o 指向的对象

> 0: 表示 this 指向的对象大于 o 指向的对象

4.用户自定义类型，定义类时，先实现comparable接口，然后重写compareTo方法

public class Course implements Comparable<Course>{
        private String name;
        private int score;
    
        public Course(String name, int score) {
            this.name=name;
            this.score=score;
        }
    
        @Override
        public String toString() {
            return "course{" +
                    "name='" + name + '\'' +
                    ", score=" + score +
                    '}';
        }
        @Override
        public int compareTo(Course o) {
            if(o==null){
                return 1;
            }
            return score-o.score;
        }
    }

测试：

![a204188e6495478eb4deaa70fae8c5a8.png][]

实现对数组的比较：

![5bcfe023f7a84ab1a95769eba1285083.png][]

#### 2.2.3基于比较器比较 ####

1.Comparator是java.util 包中的泛型接口类，使用时必须导入对应的包。

2.Comparetor接口比Comparable接口灵活，如果要实现不同的比较关系，Comparable接口要修改Course类的代码，修改comparaTo方法；Comparetor接口可以不修改Course类的代码，实现不同的比较关系。

3.用户自定义比较器，要实现Comparator接口，覆写Comparator中的compara方法

compara方法有两个参数

public class Course{
        private String name;
        private int score;
    
        public Course(String name, int score) {
            this.name=name;
            this.score=score;
        }
    
        @Override
        public String toString() {
            return "course{" +
                    "name='" + name + '\'' +
                    ", score=" + score +
                    '}';
        }
      
        //名称比较器
        static class NameComparator implements Comparator<Course> {
            @Override
            public int compare(Course o1, Course o2) {
                return o1.name.compareTo(o2.name);
            }
        }
        //成绩比较器
        static class ScoreComparator implements  Comparator<Course>{
    
            @Override
            public int compare(Course o1, Course o2) {
                return o1.score-o2.score;
            }
        }
    }

测试：

![1e2b6ee378ce44419e0fdd853f04b8a0.png][]

### 2.3方法的对比 ###

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>方法</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>Object.equals</td> 
   <td>因为所有类都继承于Object,可以直接覆写，只能比较是否相等</td> 
  </tr> 
  <tr> 
   <td>Comparable.comparaTo</td> 
   <td>需要实现接口，一旦实现，每次用该类都有顺序</td> 
  </tr> 
  <tr> 
   <td>Comparator.compara</td> 
   <td>需要实现比较器对象，对比较类入侵弱，对算法代码入侵强</td> 
  </tr> 
 </tbody> 
</table>

[20003444c5af4e628431c05833419d6c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/4563e087ff92411e87e6bbc5e738b995.png
[a204188e6495478eb4deaa70fae8c5a8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/699e7e7d39314f1388671d86f4b9332c.png
[5bcfe023f7a84ab1a95769eba1285083.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/c50fad941bbc40d3b18f390e0f032338.png
[1e2b6ee378ce44419e0fdd853f04b8a0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/c4de36e43da948738951d9eddcc3426a.png