Java比较器

最新推荐文章于 2023-06-18 17:56:42 发布

Xc_.xC

最新推荐文章于 2023-06-18 17:56:42 发布

阅读量94

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_52215881/article/details/126916600

版权

补充一个知识点：equals()方法

equals()方法是一个Object类的方法，所以所有的对象都可以使用。

在Object类中如下：（可以看出比较的是对象的地址）

public boolean equals(Object obj) {

return (this == obj);

}

注意：但是我们平时在调用String、Integer等封装类型时的equals方法时是比较的内容是否一致而不是地址一致，因为所有的String比较都是相等的，所以封装类型都重写了equals方法。

==和equals()方法的区别：

（1）如果是基本类型比较，那么只能用==来比较，不能用equals

（2）对于基本类型的包装类型，比如Boolean、Character、Byte、Shot、Integer、Long、Float、Double等的引用变量，"=="是比较地址的，而equals是比较内容的。

（3）对于String(字符串)、StringBuffer(线程安全的可变字符序列)、StringBuilder(可变字符序列)

String也重写了equals()方法，但是对于String对象而言由一个常量池的概念，String对象的内容都会保存到常量池当中，用new来创建多个同一String对象，每个引用其实都是指向同一个字符串，所以引用是同一个引用，==也是true。

代码演示：

public class Compare01 {
    public static void main(String[] args) {
        Integer n1 = new Integer(30);
        Integer n2 = new Integer(30);

        System.out.println(n1==n2);
        System.out.println(n1.equals(n2));

        String s1="123";
        String s2="123";
        String s3="张三";
        String s4="张三";
        System.out.println(s1==s2);
        System.out.println(s1.equals(s2));
        System.out.println(s3.equals(s4));
    }
}
结果：
false
true
true
true
true

Java比较器：

为什么要使用比较器？

Java中的对象，正常情况下，只能进行比较：== 或 != 。不能使用 > 或 < 的但是在开发场景中，我们需要对多个对象进行排序，言外之意，就需要比较对象的大小。如何实现？使用两个接口中的任何一个：Comparable 或 Comparator

Comparable接口：

通常被称为：外部比较器。

1.像String、包装类等实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象大小的方式。
2.像String、包装类重写compareTo()方法以后，进行了从小到大的排列

compareTo（）方法的返回值 s1.compareTo(s2)----->>s1 与 s2 的ASC码的差值，

其实就是字典排序；
3. 重写compareTo(obj)的规则：
如果当前对象this大于形参对象obj，则返回正整数，
如果当前对象this小于形参对象obj，则返回负整数，
如果当前对象this等于形参对象obj，则返回零。
4. 对于自定义类来说，如果需要排序，我们可以让自定义类实现Comparable接口，重写compareTo(obj)方法。在compareTo(obj)方法中指明如何排序

代码示例：

用TreeSet集合来举例，TreeSet集合遍历时，必须使用比较器。

public class Goods implements Comparable {
    private String name;
    private double price;

    public Goods() {
    }

    public Goods(String name, double price) {
        this.name = name;
        this.price = price;
    }

    //按照商品的价格排序，由低到高，如果相同用名字进行排序
    @Override
    public int compareTo(Object o) {
        if(o instanceof Goods){
            Goods goods=(Goods) o;
            if(this.price>goods.price){
                return 1;
            }else if(this.price< goods.price){
                return -1;
            }else {
                //return 0;
                //调用字符串的compareTo方法，按照字典顺序进行排序
                return this.name.compareTo(goods.name);
            }
        }
        throw new RuntimeException("传入的数据不一致");
    }

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

第二种简单比较方法：

    //按照商品的名字进行排序，字典顺序
    @Override
    public int compareTo(Object o) {
        if(o instanceof Goods){
            Goods goods=(Goods) o;
            return String.CASE_INSENSITIVE_ORDER.compare(this.name,goods.name);
        }
        throw new RuntimeException("传入的数据不一致");
    }

public class Compare02 {
    public static void main(String[] args) {
        Set set=new TreeSet();

        set.add(new Goods("衣服",20));
        set.add(new Goods("裤子",10));
        set.add(new Goods("帽子",20));
        System.out.println(set);
    }
}
结果：
[Goods{name='裤子', price=10.0}, Goods{name='帽子', price=20.0}, 
Goods{name='衣服', price=20.0}]

Comparator接口：

通常被称为内部比较器：

什么时候使用？
1，当元素的类型没实现java.lang.Comparable接口而又不方便修改代码，

2，实现了java.lang.Comparable接口的排序规则不适合当前的操作，那么可以考虑使用 Comparator 的对象来排序

2.重写compare(Object o1,Object o2)方法，比较o1和o2的大小：
如果方法返回正整数，则表示o1大于o2；
如果返回0，表示相等；
返回负整数，表示o1小于o2。

代码示例：

public class Goods02 {
    private String name;
    private double price;

    //直接在创建对象的时候，定义构造器。
    //按照价格排序，由高到低，如果价格一样，按名字的字典顺序排序
    Comparator c= new Comparator(){
        @Override
        public int compare(Object o1, Object o2) {
            if (o1 instanceof Goods02 && o2 instanceof Goods02){
                Goods02 g1=(Goods02) o1;
                Goods02 g2=(Goods02) o2;
                if (g1.getName().equals(g2.getName())){
                    //调用Double包装类的compare方法比较。
                    return Double.compare(g1.getPrice(),g2.getPrice());
                }else {
                    //调用了String类的compareTo方法
                    return g1.getName().compareTo(g2.getName());
                }
            }
            throw new RuntimeException("输入的数据类型不一样");
        }
    };

实际运用，在TreeSet集合中：

public class Goods02 {
}
public class Compare03 {
    public static void main(String[] args) {
        Set set=new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof Goods02 && o2 instanceof Goods02){
                    Goods02 g1=(Goods02) o1;
                    Goods02 g2=(Goods02) o2;
                     //直接在创建对象的时候，定义构造器。
                    //按照价格排序，由高到低，如果价格一样，按名字的字典顺序排序
                    if (g1.getName().equals(g2.getName())){
                        //调用Double包装类的compare方法比较。
                        return Double.compare(g1.getPrice(),g2.getPrice());
                    }else {
                        //调用了String类的compareTo方法
                        return g1.getName().compareTo(g2.getName());
                    }
                }
                throw new RuntimeException("输入的数据类型不一样");
            }
        });
        set.add(new Goods02("衣服",20));
        set.add(new Goods02("裤子",10));
        set.add(new Goods02("帽子",20));
        System.out.println(set);
    }
}
结果：
[Goods02{name='帽子', price=20.0}, Goods02{name='衣服', price=20.0},
 Goods02{name='裤子', price=10.0}]

简单的重写

     Set set=new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof Goods02 && o2 instanceof Goods02) {
                    Goods02 g1 = (Goods02) o1;
                    Goods02 g2 = (Goods02) o2;
                    //调用了String类的compare方法
                    //直接使用名字进行排序
                    return  
                    String.CASE_INSENSITIVE_ORDER.compare(g1.getName(),g2.getName());
                }
                throw new RuntimeException("输入的数据类型不一样");
            }
        });