浅谈Compartor和Comperable接口

Comparable 和 Comparator 都是用来实现集合中元素的比较、排序的，接下来我们具体来谈谈两个接口。

注：Comparator位于java.util包下，Comparable位于java.lang包下

Comparator接口

public interface Comparator<T>

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

 

Comparator定义了俩个方法，分别是   int   compare(T   o1,   T   o2)和   boolean   equals(Object   obj)

 

int compare(T o1,T o2)

 

比较用来排序的两个参数。根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。

在前面的描述中，符号 sgn(expression) 表示 signum 数学函数，根据 expression 的值为负数、0 还是正数，该函数分别返回 -1、0 或 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 不一致的排序。”

参数：

o1 - 要比较的第一个对象。

o2 - 要比较的第二个对象。

返回：

根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。

抛出：

ClassCastException - 如果参数的类型不允许此 Comparator 对它们进行比较。

 

equals

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

注意：

在实现Comparator接口时，并没有实现equals方法，可程序并没有报错，原因是实现该接口的类也是Object类的子类，而Object类已经实现了equals方法；

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

 

覆盖：

类 Object 中的 equals

参数：

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

返回：

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

另请参见：

Object.equals(Object), Object.hashCode()

 

Comparable接口

 

public interface Comparable<T>

此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。

实现此接口的对象列表（和数组）可以通过 Collections.sort（和 Arrays.sort）进行自动排序。实现此接口的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

Comparable 是一个对象本身就已经支持自比较所需要实现的接口（如 String、Integer 自己就可以完成比较大小操作，已经实现了Comparable接口）

 

Comparable接口只提供了   int  compareTo(T  o)方法

 

compareTo

int compareTo(T o)比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

实现类必须确保对于所有的 x 和 y 都存在 sgn(x.compareTo(y)) == -sgn(y.compareTo(x)) 的关系。（这意味着如果 y.compareTo(x) 抛出一个异常，则 x.compareTo(y) 也要抛出一个异常。）

实现类还必须确保关系是可传递的：(x.compareTo(y)>0 && y.compareTo(z)>0) 意味着 x.compareTo(z)>0。

最后，实现者必须确保 x.compareTo(y)==0 意味着对于所有的 z，都存在 sgn(x.compareTo(z)) == sgn(y.compareTo(z))。 强烈推荐 (x.compareTo(y)==0) == (x.equals(y)) 这种做法，但并不是 严格要求这样做。一般来说，任何实现 Comparable 接口和违背此条件的类都应该清楚地指出这一事实。推荐如此阐述：“注意：此类具有与 equals 不一致的自然排序。”

在前面的描述中，符号 sgn(expression) 指定 signum 数学函数，该函数根据 expression 的值是负数、零还是正数，分别返回 -1、0 或 1 中的一个值。

 

参数：

o - 要比较的对象。

返回：

负整数、零或正整数，根据此对象是小于、等于还是大于指定对象。

抛出：

ClassCastException - 如果指定对象的类型不允许它与此对象进行比较。

Collections使用：Collections.sort（集合）

通过案例我们来更好的理解两个接口

 

案例：定义员工类，属性有姓名，部门，ID，等级

          在集合中添加十个员工，

          先对部门进行排序，

          后对等级进行排序，

          最后对员工ID进行排序。

定义员工类并实现Comparable接口重写co没pareTo（）方法：

建议养成良好习惯，必要的属性定义为私有的；

public class Staff implements Comparable<Staff>{

private String name ;
private String brinch;
private int ID;
private String rank;
public Staff() {}
public Staff(String name,String brinch, int ID,String rank) {
	this.name = name ;
	this.brinch = brinch;
	this.ID = ID;
	this.rank = rank;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public String getBrinch() {
	return brinch;
}
public void setBrinch(String brinch) {
	this.brinch = brinch;
}
public int getID() {
	return ID;
}
public void setID(int iD) {
	ID = iD;
}
public String getRank() {
	return rank;
}
public void setRank(String rank) {
	this.rank = rank;
}

@Override
public String toString() {
	return "Staff [name=" + name + ", brinch=" + brinch + ", ID=" + ID + ", rank=" + rank + "]";
}
//实现Comparable重写comparTo方法，对员工的部门进行排序
@Override
public int compareTo(Staff o) {
	// TODO Auto-generated method stub
	return this.brinch.compareTo(o.brinch);
}
}

定义StaffComparator 类实现Compartor接口重写compare（）方法，即所说引入的裁判。

import java.util.Comparator;
//实现Compartor接口即所说引入的裁判。
public class StaffComparator  implements Comparator<Staff>{
        //重写Comparator的compare方法对员工等级进行排序。
	@Override
	public int compare(Staff o1, Staff o2) {
		return o1.getRank().compareTo(o2.getRank());
	}

}

测试类：其中可以只使用匿名内部类重写Compartor的compare（）方法，但为了更好体现Compartor和Comparable区别，后面使用了多种方式，根据自己习惯使用

public class Test {
public static void main(String[] args) {
//	Staff sta = new Staff();
	List<Staff> staList = new ArrayList<Staff>();
	staList.add(new Staff("a","jishu",23456,"A"));
	staList.add(new Staff("r","renshi",12356,"D"));
	staList.add(new Staff("w","daongshiban",123456,"C"));
	staList.add(new Staff("f","jishu",3456,"B"));
	staList.add(new Staff("c","daongshiban",123456,"B"));
	staList.add(new Staff("d","renshi",2345,"D"));
	staList.add(new Staff("b","jishu",3456,"C"));
	staList.add(new Staff("a","daongshiban",123456,"A"));
	staList.add(new Staff("d","cnegzheng",3456,"B"));
	staList.add(new Staff("a","renshi",23456,"D"));
	staList.add(new Staff("a","caizheng",56,"B"));
	//使用匿名内部类对员工的ID进行排序
	Collections.sort(staList,new Comparator<Staff>() {

		@Override
		public int compare(Staff o1, Staff o2) {
			// TODO Auto-generated method stub
			return o1.getID()-o2.getID();
		}
	});
	
	//使用StaffCompartor实现Compartor重写compare方法对员工等级进行排序
        Collections.sort(staList,new StaffComparator());
        //这里使用的就是Stff类重写Compartable的compareTo方法
//	Collections.sort(staList);
        //使用匿名内部类对员工的部门进行排序，与上一行代码同样效果。
	Collections.sort(staList,new Comparator<Staff>() {

		@Override
		public int compare(Staff o1, Staff o2) {
			// TODO Auto-generated method stub
			return o1.getBrinch().compareTo(o2.getBrinch());
		}
	});
	for(Staff q:staList) {
		System.out.println(q);
	}
}
}