Java日常学习之- - -比较

目录

基础类型的比较

引用类型的比较

1.equals方法

2.CompareTO接口 

3.Comparator接口 

---

基础类型的比较

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

包括：

1.数值类型

        可以进行，大小比较与相等比较

2.字符类型

        同样可以进行，大小与相等比较

3.布尔类型

        只能进行相等比较

public static void main(String[] args) {
        //数值类型
        int a=12;
        int b=55;
        System.out.println(a > b);
        System.out.println(a == b);
        System.out.println(a<b);

        //字符类型
        //字符的比较根据字符所对应ASCII值来比较大小
        char ch1='a';
        char ch2='b';
        char ch3='c';
        System.out.println(ch1>ch2);
        System.out.println(ch1==ch2);
        System.out.println(ch1<ch2);

        //布尔类型
        boolean b1=true;
        boolean b2=false;
        System.out.println(b1==b2);
        System.out.println(b1!=b2);
    }

引用类型的比较

        在Java中，引用类型变量（对象）间只能判断两个变量是否相等（==,!=），如果直接进行大小比较（> , < , >= ,<= , !> , !< , ......）则会报错，且直接比较变量是否相等时会出现与预期效果不一样的情况.

这是为什么呢？

        因为！除了string是比较其值外，其余都是比较其引用（即对象的存储地址，地址相同则视为相等）

在这里我总结了三种比较引用类型变量(对象)的方法

1.equals方法

示例如下：

class Card{
    public int rank;
    public String suit;
    public Card(int rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        // o如果是null对象，或者o不是Card的子类
        if (o == null || !(o instanceof Card)) return false;
        Card card = (Card) o;
        return rank == card.rank && Objects.equals(suit, card.suit);
    }
}
Public class Main{
public static void main(String[] args){
		Card c1 = new Card(1, "♠");
        Card c2 = new Card(1, "♠");
        System.out.println(c1.equals(c2));
}
}

其equal方法实现如下：

1. 如果这个类指向同一个对象则直接返回true;
2. 如果传入的为空或者其对象类型不是Card，则返回false
3. 按照类的实现目标完成比较，这里只要花色和数值一样，就认为是相同的牌
4. 注意下调用其他引用类型的比较也需要 equals，例如这里的 suit 的比较

2.CompareTO接口 

Comparble是JDK提供的泛型的比较接口类，源码实现具体如下：

public interface Comparable<E>{
// 返回值:
// < 0: 表示 this 指向的对象小于 o 指向的对象
// == 0: 表示 this 指向的对象等于 o 指向的对象
// > 0: 表示 this 指向的对象等于 o 指向的对象
public int compareTo(T o);
}

对于用户自定义类型，如果按照大小与方式进行比较：可以在定义类的时候实现接口Comparable，并在类中重写compareTo方法。

class Card implements Comparable<Card>{
    public int rank;
    public String suit;
    public Card(int rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }

    @Override
    public int compareTo(Card o) {
        return this.rank-o.rank;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || !(o instanceof Card)) return false;
        Card card = (Card) o;
        return rank == card.rank && Objects.equals(suit, card.suit);
    }
}
public class Main {
    public static void main(String[] args) {
        Card p = new Card(1, "♠");
        Card q = new Card(2, "♠");
        Card o = new Card(1, "♠");
        System.out.println(p.compareTo(o)); // == 0，表示牌相等
        System.out.println(p.compareTo(q));// < 0，表示 p 比较小
        System.out.println(q.compareTo(p));// > 0，表示 q 比较大
    }
    }

3.Comparator接口 

按照比较器方式进行比较，具体步骤如下:

1. 自定义比较器类，实现Comparator接口（）
2. 重写Comparator中的compare方法

实例如下：

class Card{
    public int rank;
    public String suit;
    public Card(int rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || !(o instanceof Card)) return false;
        Card card = (Card) o;
        return rank == card.rank && Objects.equals(suit, card.suit);
    }
}
class CardComparator implements Comparator<Card>{
    @Override
    // 返回值:
    // < 0: 表示 o1 指向的对象小于 o2 指向的对象
    // == 0: 表示 o1 指向的对象等于 o2 指向的对象
    // > 0: 表示 o1 指向的对象等于 o2 指向的对象
    public int compare(Card o1, Card o2) {
       if (o1 == o2) {
            return 0;
        }
        //判断o1是否为空
        if (o1 == null) {
            return -1;
        }
        //判断o2是否为空
        if (o2 == null) {
            return 1;
        }
        return o1.rank - o2.rank;
    }
}
public class Main {
     public static void main(String[] args) {
        Card p = new Card(1, "♠");
        Card q = new Card(2, "♠");
        Card o = new Card(1, "♠");
        //定义比较器对象
        CardComparator cmptor = new CardComparator();
        // 使用比较器对象进行比较
        // == 0，表示牌相等
        System.out.println(cmptor.compare(p, o)); 
        // < 0，表示 p 比较小
        System.out.println(cmptor.compare(p, q)); 
        // > 0，表示 q 比较大
        System.out.println(cmptor.compare(q, p)); 
    }
}

三种比较方式的对比

方法	解释说明
Object.equals	因为所有类都是默认继承自Object 的，所以直接重写此方法即可自定义比较，不过只能比较是否相等
Comparable.compareTo	需要手动在类中，实现接口，侵入性比较强，但一旦实现，每次用该类都有顺序，属于内部顺序
Comparator.compare	需要实现一个比较器对象，对待比较类的侵入性弱，但对算法代码实现侵入性强

感谢各位小伙伴的点赞关注与评论！博客实时更新，注意查收！