java:比较器

后端 java
发布时间 :
字数:1.5k 阅读 :
  1. 自然排序：Comparable 接口
    1. 引入案例
    2. 如何使用Comparable 接口
  2. 定制排序：Comparator接口

课程：宋红康 JAVA

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

自然排序：Comparable 接口

引入案例

@Test
public void test1(){
    String[] arr = new String[]{"AA","CC","KK","MM","GG","JJ","DD"};
    Arrays.sort(arr);
    System.out.println(Arrays.toString(arr));
}

public int compareTo(String anotherString) {
    int len1 = value.length;
    int len2 = anotherString.value.length;
    int lim = Math.min(len1, len2);
    char v1[] = value;
    char v2[] = anotherString.value;
    int k = 0;
    while (k < lim) {
        char c1 = v1[k];
        char c2 = v2[k];
        if (c1 != c2) {
            return c1 - c2;
        }
        k++;
    }
    return len1 - len2;
}

因为 String 实现了 Comparable 接口，实现了 compareTo 方法。

这个方法：把两个字符串变成 char 型数组，然后依次比较，如果为负数就表明比 anotherString 小

@return：the value {@code 0} if the argument string is equal to this string;

a value less than {@code 0} if this string is lexicographically less than the string argument;

and a value greater than {@code 0} if this string is lexicographically greater than the string argument.

如何使用Comparable 接口

  • 像 String、包装类等实现了 Comparable 接口，重写了 compareTo(obj)方法，给出了比较两个对象大小的方式。
  • 像 String、包装类重写 compareTo()方法以后，进行了从小到大的排列。
  • 重写 compareTo(obj)的规则：
    • 如果当前对象 this 大于形参对象 obj，则返回正整数，
    • 如果当前对象 this 小于形参对象 obj，则返回负整数，
    • 如果当前对象 this 等于形参对象 obj，则返回零。
  • 对于自定义类来说，如果需要排序，我们可以让自定义类实现 Comparable 接口，重写 compareTo(obj)方法。在 compareTo(obj)方法中指明如何排序。
  • 实现 Comparable 接口的对象列表(和数组)可以通过 Collections.sort 或 Arrays.sort 进行自动排序。实现此接口的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
  • 对于类 C 的每一个 e1 和 e2 来说，当且仅当 e1.compareTo(e2)==0 与 e1.equals(e2)具有相同的 boolean 值时，类 C 的自然排序才叫做与 equals 一致。建议(虽然不是必需的)最好使自然排序与 equals 一致。
  • Comparable 的典型实现: (默认都是从小到大排列的)
    • String：按照字符串中字符的 Unicode 值进行比较
    • Character：按照字符的 Unicode 值来进行比较
    • 数值类型对应的包装类以及 BigInteger、BigDecimal:按照它们对应的数值大小进行比较
    • Boolean:true 对应的包装类实例大于 false 对应的包装类实例
    • Date、Time 等:后面的日期时间比前面的日期时间大

代码实现

@Test
public void test233(){
    Goods[] arr = new Goods[3];
    arr[0] = new Goods("A1",10);
    arr[1] = new Goods("A2",12);
    arr[2] = new Goods("A3",12);
    Arrays.sort(arr);// 从小到大排列
    //[Goods{name='A1', price=10.0}, Goods{name='A3', price=12.0}, Goods{name='A2', price=12.0}]
    System.out.println(Arrays.toString(arr));
}

public class Goods implements  Comparable{

    private String name;
    private double price;

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

    //指明商品比较大小的方式:按照价格从低到高排序,再按照产品名称从高到低排序（由高到低，意味数值高的更小，所以要加负号）
    //{price=10,name=A1} < {price=12,name=A3} < {price=12,name=A2}
    @Override
    public int compareTo(Object o) {
        //  System.out.println("**************");
        if(o instanceof Goods){
            Goods goods = (Goods)o;
            //方式一：
            if(this.price > goods.price){
                return 1;
            }else if(this.price < goods.price){
                return -1;
            }else{
                // 如果价格是一样的，再比较名字
                // -1: this < argument
                // 1: this > argument
                // 按照产品名称从高到低排序（由高到低，意味数值高的更小，所以要加负号）
               // return 0;
               return -this.name.compareTo(goods.name);
            }
            //方式二：
          // return Double.compare(this.price,goods.price);
        }
        //return 0;
        throw new RuntimeException("传入的数据类型不一致！");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

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

定制排序：Comparator接口

  1. 重写compare(Object o1,Object o2)方法，比较o1和o2的大小：
    • 如果方法返回正整数，则表示o1大于o2；
    • 如果返回0，表示相等；
    • 返回负整数，表示o1小于o2。
  2. 可以将Comparator传递给sort方法(如Collections. sort或Arrays.sort) ,从而允许在排序顺序上实现精确控制。
  3. 还可以使用Comparator来控制某些数据结构(如有序set或有序映射)的顺序，或者为那些没有自然顺序的对象collection提供排序。
@Test
public void test31(){
    String[] arr = new String[]{"AA","CC","KK","MM","GG","JJ","DD"};
    Arrays.sort(arr,new Comparator(){
        //按照字符串从大到小的顺序排列
        @Override
        public int compare(Object o1, Object o2) {
            if(o1 instanceof String && o2 instanceof  String){
                String s1 = (String) o1;
                String s2 = (String) o2;
                return -s1.compareTo(s2);
            }
            //return 0;
            throw new RuntimeException("输入的数据类型不一致");
        }
    });
    System.out.println(Arrays.toString(arr));
}

@Test
public void test42(){
    Goods[] arr = new Goods[3];
    arr[0] = new Goods("A1",10);
    arr[1] = new Goods("A2",12);
    arr[2] = new Goods("A3",12);

    Arrays.sort(arr, new Comparator() {
        //指明商品比较大小的方式:按照产品名称从低到高排序,再按照价格从高到低排序
        @Override
        public int compare(Object o1, Object o2) {
            if(o1 instanceof Goods && o2 instanceof Goods){
                Goods g1 = (Goods)o1;
                Goods g2 = (Goods)o2;
                if(g1.getName().equals(g2.getName())){
                    return -Double.compare(g1.getPrice(),g2.getPrice());
                }else{
                    return g1.getName().compareTo(g2.getName());
                }
            }
            throw new RuntimeException("输入的数据类型不一致");
        }
    });
    //[Goods{name='A1', price=10.0}, Goods{name='A2', price=12.0}, Goods{name='A3', price=12.0}]
    System.out.println(Arrays.toString(arr));
}

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 1909773034@qq.com

赏

©2017 XieShaoLin

Built with Hexo and 3-hexo theme

×

喜欢就点赞,疼爱就打赏