常见的接口与类 -- Comparator

接口Comparator 1.1

  前面我们讲过Java提供了一个用于比较的接口Comparable,提供了一个比较的方法,所有实现该接口的类,都动态的实现了该比较方法。实际上Java中除了比较一个接口外,还提供了一个接口,该接口也是具有比较的功能,但该接口注重的却是比较容器,然后对其排序,这就是Comparator,下面我们就来具体认识一下;

1. 接口概述

  Comparator并不想Comparable那样有许许多多的实现类,该接口的实现类只有两个Collator, RuleBasedCollator,但是该接口提供的两个方法,仍然是十分有用的,下面我们就来详细通过API介绍一下接口,下节介绍接口方法;

查看API

public interface Comparator<T>

  强行对某个对象 collection 进行整体排序的比较函数。可以将 Comparator 传递给 sort 方法(如 Collections.sort  Arrays.sort),从而允许在排序顺序上实现精确控制。还可以使用 Comparator 来控制某些数据结构(有序 set有序映射)的顺序,或者为那些没有自然顺序的对象 collection 提供排序。

  当且仅当对于一组元素 S 中的每个e1e2 而言,c.compare(e1, e2)==0e1.equals(e2) 具有相等的布尔值时,Comparator c 强行对 S 进行的排序才叫做与 equals 一致的排序。

  当使用具有与 equals 不一致的强行排序能力的 Comparator 对有序 set(或有序映射)进行排序时,应该小心谨慎。假定一个带显式 Comparator c 的有序 set(或有序映射)与从 set S 中抽取出来的元素(或键)一起使用。如果 c 强行对 S 进行的排序是与 equals 不一致的,那么有序 set(或有序映射)将是行为怪异的。尤其是有序 set(或有序映射)将违背根据 equals 所定义的 set(或映射)的常规协定。 例如,假定使用 Comparator c 将满足 (a.equals(b) && c.compare(a, b) != 0) 的两个元素 a b 添加到一个空 TreeSet 中,则第二个 add 操作将返回 true(树 set 的大小将会增加),因为从树 set 的角度来看,a b 是不相等的,即使这与 Set.add 方法的规范相反。

  注:通常来说,让 Comparator 也实现 java.io.Serializable 是一个好主意,因为它们在可序列化的数据结构(像 TreeSetTreeMap)中可用作排序方法。为了成功地序列化数据结构,Comparator(如果已提供)必须实现 Serializable

在算术上,定义给定 Comparator c 对给定对象 set S 实施强行排序 的关系式 为:

       {(x, y) such that c.compare(x, y) <= 0}.

此整体排序的商 (quotient) 为:

       {(x, y) such that c.compare(x, y) == 0}.

  它直接遵循 compare 的协定,商是 S 上的等价关系,强行排序是 S 上的整体排序。当我们说 c 强行对 S 的排序是与 equals 一致 的时,意思是说排序的商是对象的 equals(Object) 方法所定义的等价关系:

       {(x, y) such that x.equals(y)}.

此接口是 Java Collections Framework 的成员。

2. 接口方法详解

  作为接口Comparator提供了两个抽象方法,如下:

int

compare(T o1, T o2) 比较用来排序的两个参数。

 boolean

equals(Object obj) 指示某个其他对象是否等于Comparator

  通过API,我们来解读接口方法:

  Compare()比较用来排序的两个参数。根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。 在前面的描述中,符号 sgn(expression) 表示 signum 数学函数,根据 expression 的值为负数、0 还是正数,该函数分别返回 -10 1

  • 实现程序必须确保对于所有的 x y 而言,都存在 sgn(compare(x, y)) == -sgn(compare(y, x))。(这意味着当且仅当 compare(y, x) 抛出异常时 compare(x, y) 才必须抛出异常。)
  • 实现程序还必须确保关系是可传递的:((compare(x, y)>0) && (compare(y, z)>0)) 意味着 compare(x, z)>0
  • 最后,实现程序必须确保 compare(x, y)==0 意味着对于所有的 z 而言,都存在 sgn(compare(x, z))==sgn(compare(y, z))

  虽然这种情况很普遍,但并不 严格要求 (compare(x, y)==0) == (x.equals(y))。一般说来,任何违背这个条件的 Comparator 都应该清楚地指出这一事实。推荐的语言是“注意:此 Comparator 强行进行与 equals 不一致的排序。”

    可能抛出异常ClassCastException - 如果参数的类型不允许此 Comparator 对它们进行比较。

  Equals()指示某个其他对象是否“等于”此 Comparator。此方法必须遵守 Object.equals(Object) 的常规协定。此外,仅当 指定的对象也是一个 Comparator,并且强行实施与此 Comparator 相同的排序时,此方法才返回 true。因此,comp1.equals(comp2) 意味着对于每个对象引用 o1 o2 而言,都存在 sgn(comp1.compare(o1, o2))==sgn(comp2.compare(o1, o2))

  注意,不重写 Object.equals(Object) 方法总是安全的。然而,在某些情况下,重写此方法可以允许程序确定两个不同的 Comparator 是否强行实施了相同的排序,从而提高性能。

覆盖: Object 中的 equals

参数: obj - 要进行比较的引用对象。

返回: 仅当指定的对象也是一个 Comparator,并且强行实施与此 Comparator 相同的排序时才返回 true

3. 接口方法实践操作

  上面我们对接口中的两个方法进行了一番概述,那么接下来我们就来实践操作一下这两个方法。

package cn.comparator.A;
import java.util.Comparator;
/**
     * 我们考虑这样一种情况,那么就是一个String类型的数组,我们希望数组的排序是
     * 按照字符串的长度来排序,而不是字典书序,那么此时显然String的compareTo不适用了,
     * 并且String是final类,也不允许我们更改,那么此时该怎么做呢?
     * Arrays提供了一个用于排序的sort方法,如果不传递比较器的话,
     * 那么默认使用该类型的比较器进行比较,这里要比较的是String,String的比较器不符合我们
     * 的需求,那么最好的做法就是自己定义个比较器,然后传递进去,下面来试一下
     */
public class ComparatorLength implements Comparator<String>{
    /**
     * 如果参数1的长度大于参数2的长度,那么返回1,否则返回-1
     */
    @Override
    public int compare(String o1, String o2) {
        int len1 = o1.length();
        int len2 = o2.length();
        return (len1 - len2 > 0) ? 1 : -1;
    }
}
@Test
    public void test2(){
        String[] str = {"aadsaf","dqwd","dqwfcsqc","xqsccaac","csfwffqaf","czxca","cas","cacs","casc"};
        Comparator com1 = new ComparatorLength();
        Comparator com2 = new ComparatorLength();
        Arrays.sort(str, com1);
        System.out.println(Arrays.toString(str));
        Arrays.sort(str, com2);
        System.out.println(Arrays.toString(str));
        System.out.println((com1 == com2) +"--"+ (com1.equals(com2)));
    }

  上面我们简单对Comparator的方法进行了实践,那么我们考虑对数组进行更详细的排序,按照字符排序,并且重写equals方法,注意equals方法是重写Object的,Comparator虽然具有equals,但是使用Eclipse快捷重写该方法时,没有任何提示,下面我们来看一下:

package cn.comparator.A;
import java.util.Comparator;
public class ComparatorLeng implements Comparator<String>{
    /**
     * 比较字符串元素
     */
    @Override
    public int compare(String o1, String o2) {
        return o1.compareTo(o2);
    }
    @Override
    public boolean equals(Object o) {
        Comparator com = (Comparator) o;
        return this.compare(o1, o2) == com.compare(o1, o2);
    }
}
@Test
    public void test3(){
        String[] str = {"aadsaf","dqwd","dqwfcsqc","xqsccaac","csfwffqaf","czxca","cas","cacs","casc"};
        Comparator com1 = new ComparatorLeng();
        Comparator com2 = new ComparatorLeng();
        Arrays.sort(str, com1);
        System.out.println(Arrays.toString(str));
        Arrays.sort(str, com2);
        System.out.println(Arrays.toString(str));
        System.out.println((com1 == com2) +"--"+ (com1.equals(com2)));
    }

 

我们看到实现了既定操作,我们考虑一下,我们是学习过排序算法的,那么试验一下:

package cn.comparator.A;
import java.util.Comparator;
public class ComparatorLeng implements Comparator<String>{
    String o1 = "sacWDVWdvWDSCDXCsfsdf";
    String o2 = "FWEFxsafcsdavxFWEFVcss";
    /**
     * 比较字符串元素
     */
    @Override
    public int compare(String o1, String o2) {
        return o1.compareTo(o2);
    }
    @Override
    public boolean equals(Object o) {
        Comparator com = (Comparator) o;
        return this.compare(o1, o2) == com.compare(o1, o2);
    }
    public Comparable[] sort(Comparable<String>[] arr){
        //将数组按照升序排列
        int len = arr.length;
        for (int i = 0; i < len; i++) {
            //将arr[i]插入到arr[i-1],arr[i-2]....之中去
            for (int j = i; j > 0 && less(arr[j], arr[j-1]); j--) {
                //交换arr[j]和arr[j-1]元素
                exch(arr, j, j-1);
            }
        }
        return arr;
    }
    //比较数组元素
    public boolean less(Comparable c1,Comparable c2){
        return c1.compareTo(c2) < 0;
    }
    //交换元素
    public void exch(Comparable[] com, int i,int j){
        Comparable ce = com[i];
        com[i] = com[j];
        com[j] = ce;
    }
}
@Test
    public void test4(){
        String[] str = {"aadsaf","dqwd","dqwfcsqc","xqsccaac","csfwffqaf","czxca","cas","cacs","casc"};
        String[] str1 = {"aadsaf","dqwd","dqwfcsqc","xqsccaac","csfwffqaf","czxca","cas","cacs","casc"};
        ComparatorLeng com1 = new ComparatorLeng();
        str = (String[]) com1.sort(str);
        System.out.println(Arrays.toString(str));
        Arrays.sort(str1, com1);
        System.out.println(Arrays.toString(str1));
    }

综上,我们简单了解了Comparator的方法,我们会在以后的学习中进行加强学习,这个是后话了;

posted @ 2018-01-13 15:22  十月十四  阅读(14683)  评论(0编辑  收藏  举报