深入理解 Comparable 接口和 Comparator 接口以及Arrays.sort()
2016-05-16 09:45
549 查看
compareTo(Object o)方法是java.lang.Comparable<T>接口中的方法,当需要对某个类的对象进行排序时,该类需要实现Comparable<T>接口的,必须重写public int compareTo(T
o)方法,比如MapReduce中Map函数和Reduce函数处理的 <key,value>,其中需要根据key对键值对进行排序,所以,key实现了WritableComparable<T>接口,实现这个接口可同时用于序列化和反序列化。WritableComparable<T>接口(用于序列化和反序列化)是Writable接口和Comparable<T>接口的组合;
compare(Object o1,Object o2)方法是java.util.Comparator<T>接口的方法,它实际上用的是待比较对象的compareTo(Object o)方法。
1. 两种比较接口分析
在 “ 集合框架 ” 中有两种比较接口: Comparable 接口和 Comparator 接口。 Comparable 是通用的接口,用户可以实现它来完成自己特定的比较,而 Comparator 可以看成一种算法的实现,在需要容器集合实现比较功能的时候,来指定这个比较器,这可以看成一种设计模式,将算法和数据分 离。
前者应该比较固 定,和一个具体类相绑定,而后者比较灵活,它可以被用于各个需要比较功能的类使用。
一个类实现了 Camparable 接口表明这个类的对象之间是可以相互比较的。如果用数学语言描述的话就是这个类的对象组成的集合中存在一个全序。这样,这 个类对象组成的集合就可以使用 Sort 方法排序了。
而 Comparator 的作用有两个:
1 、如果类的设计师没有考虑到 Compare 的问题而没有实现 Comparable 接口,可以通过 Comparator 来实现比较算法进行排序;
2 、为了使用不同的排序标准做准备,比如:升序、降序或其他什么序。
2 Comparable 接口
java.lang. Comparable 接口定义类的自然顺序,实现该接口的类就可以按这种方式排序。
1 ) int compareTo(Object o): 比较当前实例对象与对象 o ,如果位于对象 o 之前,返回负值,如果两个对象在排序中位置相同,则返回 0 ,如果位于对象 o 后面,则返回正值。
2 )在 Java 2 SDK 版本 1.4 中有二十四个类实现 Comparable 接口。下表展示了 8 种基本类型的自然排序。虽然一些类共享同一种自然排序,但只有相互可比的类才能排序。
利用 Comparable 接口创建自己的类的排序顺序,只是实现 compareTo() 方法的问题。通常就是依赖几个数据成员的自然排序。同时类也应该覆盖 equals() 和 hashCode() 以确保两个相等的对象返回同一个哈希码。
这个接口的作 用:如果数组或者集合中的(类)元素实现了该接口的话 , 我们就可以调用 Collections.sort 和Arrays.sort 排序,或应用于有序集合 TreeSet 和 TreeMap 中。
下面设计一个有 序的类 Person ,它实现 Comparable 接口,以年龄为第一关键字,姓名为第二关键字升序排序。
Person.java
2.1 测试 Arrays.sort ()方法
ArraysSortUnit.java
结果:
[20{Tom}, 20{Jeff}, 30{Mary}, 20{Ada}, 40{Walton}, 61{Peter}, 20{Bush}]
[20{Ada}, 20{Bush}, 20{Jeff}, 20{Tom}, 30{Mary}, 40{Walton}, 61{Peter}]
2.2 测试 Collections.sort ()方法
CollctionsSortUnit.java
结果:
[20{Tom}, 20{Jeff}, 30{Mary}, 20{Ada}, 40{Walton}, 61{Peter}, 20{Bush}]
[20{Ada}, 20{Bush}, 20{Jeff}, 20{Tom}, 30{Mary}, 40{Walton}, 61{Peter}]
2.3 测试 TreeSet
TreeSetUnit.java
结果:
[20{Ada}, 20{Bush}, 20{Jeff}, 20{Tom}, 30{Mary}, 40{Walton}, 61{Peter}]
2.4 测试 TreeMap
TreeMapUnit.java
结果:
{20{Ada}=Ada, 20{Bush}=Bush, 20{Jeff}=Jeff, 20{Tom}=Tom, 30{Mary}=Mary, 40{Walton}=Walton, 61{Peter}=Peter}
转自 http://www.blogjava.net/fastunit/archive/2008/04/08/191533.html
三、Comparator和Comparable的区别
先看一下使用Comparator对User集合实现排序的方式:
import java.util.Arrays;
import java.util.Comparator;
public class UserComparator implements Comparator {
public int compare(Object o1, Object o2) {
return ((User) o1).getAge() - ((User) o2).getAge();
}
/**
* 测试方法
*/
public static void main(String[] args) {
User[] users = new User[] { new User( " a " , 30 ), new User( " b " , 20 ) };
Arrays.sort(users, new UserComparator());
for ( int i = 0 ; i < users.length; i ++ ) {
User user = users[i];
System.out.println(user.getId() + " " + user.getAge());
}
}
}
一个类实现了Camparable接口则表明这个类的对象之间是可以相互比较的,这个类对象组成的集合就可以直接使用sort方法排序。
Comparator可以看成一种算法的实现,将算法和数据分离,Comparator也可以在下面两种环境下使用:
1、类的设计师没有考虑到比较问题而没有实现Comparable,可以通过Comparator来实现排序而不必改变对象本身
2、可以使用多种排序标准,比如升序、降序等
Arrays.sort(T[], Comparator < ? super T > c) 方法用于对象数组按用户自定义规则排序.
官方Java文档只是简要描述此方法的作用,并未进行详细的介绍,本文将深入解析此方法。
1. 简单示例
sort方法的使用非常的简单明了,下面的例子中,先定义一个比较Dog大小的Comparator,然后将其实例对象作为参数传给sort方法,通过此示例,你应该能够快速掌握Arrays.sort()的使用方法。
[java] view
plain copy
import java.util.Arrays;
import java.util.Comparator;
class Dog{
int size;
public Dog(int s){
size = s;
}
}
class DogSizeComparator implements Comparator<Dog>{
@Override
public int compare(Dog o1, Dog o2) {
return o1.size - o2.size;
}
}
public class ArraySort {
public static void main(String[] args) {
Dog d1 = new Dog(2);
Dog d2 = new Dog(1);
Dog d3 = new Dog(3);
Dog[] dogArray = {d1, d2, d3};
printDogs(dogArray);
Arrays.sort(dogArray, new DogSizeComparator());
printDogs(dogArray);
}
public static void printDogs(Dog[] dogs){
for(Dog d: dogs)
System.out.print(d.size + " " );
System.out.println();
}
}
输出为:
[plain] view
plain copy
2 1 3
1 2 3
2. 使用策略模式
这是策略模式(Strategy
pattern)的一个完美又简洁的示例,值得一提的是为什么这种场景下适合使用策略模式.
总体来说,策略模式允许在程序执行时选择不同的算法.比如在排序时,传入不同的比较器(Comparator),就采用不同的算法.
根据上面的例子,假设你想要根据Dog的重量来进行排序,可以像下面这样,创建一个新的比较器来进行排序:
[java] view
plain copy
class Dog{
int size;
int weight;
public Dog(int s, int w){
size = s;
weight = w;
}
}
class DogSizeComparator implements Comparator<Dog>{
@Override
public int compare(Dog o1, Dog o2) {
return o1.size - o2.size;
}
}
class DogWeightComparator implements Comparator<Dog>{
@Override
public int compare(Dog o1, Dog o2) {
return o1.weight - o2.weight;
}
}
public class ArraySort {
public static void main(String[] args) {
Dog d1 = new Dog(2, 50);
Dog d2 = new Dog(1, 30);
Dog d3 = new Dog(3, 40);
Dog[] dogArray = {d1, d2, d3};
printDogs(dogArray);
Arrays.sort(dogArray, new DogSizeComparator());
printDogs(dogArray);
Arrays.sort(dogArray, new DogWeightComparator());
printDogs(dogArray);
}
public static void printDogs(Dog[] dogs){
for(Dog d: dogs)
System.out.print("size="+d.size + " weight=" + d.weight + " ");
System.out.println();
}
}
执行结果:
[plain] view
plain copy
size=2 weight=50 size=1 weight=30 size=3 weight=40
size=1 weight=30 size=2 weight=50 size=3 weight=40
size=1 weight=30 size=3 weight=40 size=2 weight=50
Comparator 是一个接口,所以sort方法中可以传入任意实现了此接口的类的实例,这就是策略模式的主要思想.
3. 为何使用"super"
如果使用 "Comparator < T > c" 那是很简单易懂的,但是sort的第2个参数里面的 < ? super T > 意味着比较器所接受的类型可以是T或者它的超类. 为什么是超类呢? 答案是: 这允许使用同一个比较器对不同的子类对象进行比较.在下面的示例中很明显地演示了这一点:
[java] view
plain copy
import java.util.Arrays;
import java.util.Comparator;
class Animal{
int size;
}
class Dog extends Animal{
public Dog(int s){
size = s;
}
}
class Cat extends Animal{
public Cat(int s){
size = s;
}
}
class AnimalSizeComparator implements Comparator<Animal>{
@Override
public int compare(Animal o1, Animal o2) {
return o1.size - o2.size;
}
//in this way, all sub classes of Animal can use this comparator.
}
public class ArraySort {
public static void main(String[] args) {
Dog d1 = new Dog(2);
Dog d2 = new Dog(1);
Dog d3 = new Dog(3);
Dog[] dogArray = {d1, d2, d3};
printDogs(dogArray);
Arrays.sort(dogArray, new AnimalSizeComparator());
printDogs(dogArray);
System.out.println();
//when you have an array of Cat, same Comparator can be used.
Cat c1 = new Cat(2);
Cat c2 = new Cat(1);
Cat c3 = new Cat(3);
Cat[] catArray = {c1, c2, c3};
printDogs(catArray);
Arrays.sort(catArray, new AnimalSizeComparator());
printDogs(catArray);
}
public static void printDogs(Animal[] animals){
for(Animal a: animals)
System.out.print("size="+a.size + " ");
System.out.println();
}
}
输出结果:
[plain] view
plain copy
size=2 size=1 size=3
size=1 size=2 size=3
size=2 size=1 size=3
size=1 size=2 size=3
4. 小结
与Arrays.sort()相关的信息总结如下:
通用: super 类
策略设计模式(strategy pattern);
归并排序(merge sort): 时间复杂度 n*log(n);
Java.util.Collections#sort(List < T > list, Comparator < ? super T > c)与Arrays.sort 使用类似的思想.
参考文献:
1. Arrays.sort(T[],
java.util.Comparator)
相关阅读:
Example
of Sorting Arrays
Java
Design Pattern: Strategy
Comparable
vs Comparator in Java
Top
10 Methods for Java Arrays
o)方法,比如MapReduce中Map函数和Reduce函数处理的 <key,value>,其中需要根据key对键值对进行排序,所以,key实现了WritableComparable<T>接口,实现这个接口可同时用于序列化和反序列化。WritableComparable<T>接口(用于序列化和反序列化)是Writable接口和Comparable<T>接口的组合;
compare(Object o1,Object o2)方法是java.util.Comparator<T>接口的方法,它实际上用的是待比较对象的compareTo(Object o)方法。
1. 两种比较接口分析
在 “ 集合框架 ” 中有两种比较接口: Comparable 接口和 Comparator 接口。 Comparable 是通用的接口,用户可以实现它来完成自己特定的比较,而 Comparator 可以看成一种算法的实现,在需要容器集合实现比较功能的时候,来指定这个比较器,这可以看成一种设计模式,将算法和数据分 离。
前者应该比较固 定,和一个具体类相绑定,而后者比较灵活,它可以被用于各个需要比较功能的类使用。
一个类实现了 Camparable 接口表明这个类的对象之间是可以相互比较的。如果用数学语言描述的话就是这个类的对象组成的集合中存在一个全序。这样,这 个类对象组成的集合就可以使用 Sort 方法排序了。
而 Comparator 的作用有两个:
1 、如果类的设计师没有考虑到 Compare 的问题而没有实现 Comparable 接口,可以通过 Comparator 来实现比较算法进行排序;
2 、为了使用不同的排序标准做准备,比如:升序、降序或其他什么序。
2 Comparable 接口
public interface Comparable<T> { public int compareTo(T o); } |
1 ) int compareTo(Object o): 比较当前实例对象与对象 o ,如果位于对象 o 之前,返回负值,如果两个对象在排序中位置相同,则返回 0 ,如果位于对象 o 后面,则返回正值。
2 )在 Java 2 SDK 版本 1.4 中有二十四个类实现 Comparable 接口。下表展示了 8 种基本类型的自然排序。虽然一些类共享同一种自然排序,但只有相互可比的类才能排序。
类 | 排序 |
BigDecimal,BigInteger,Byte,Double, Float,Integer,Long,Short | 按数字大小排序 |
Character | 按 Unicode 值的数字大小排序 |
String | 按字符串中字符 Unicode 值排序 |
这个接口的作 用:如果数组或者集合中的(类)元素实现了该接口的话 , 我们就可以调用 Collections.sort 和Arrays.sort 排序,或应用于有序集合 TreeSet 和 TreeMap 中。
下面设计一个有 序的类 Person ,它实现 Comparable 接口,以年龄为第一关键字,姓名为第二关键字升序排序。
Person.java
package com.zj.sort.comparable; public class Person implements Comparable<Person> { private int age ; private String name ; public Person( int age, String name) { this . age = age; this . name = name; } public int compareTo(Person person) { int cop = age - person.getAge(); if (cop != 0) return cop; else return name .compareTo(person. name ); } public int getAge() { return age ; } public String getName() { return name ; } public int hashCode() { int result = 17; result = 37 * result + age ; result = 37 * result + name .hashCode(); return result; } public boolean equals(Object o) { if (!(o instanceof Person)) return false ; Person person = (Person) o; return ( age == person. age ) && ( name .equals(person. name )); } public String toString() { return ( age + "{" + name + "}" ); } } |
ArraysSortUnit.java
package com.zj.sort.comparable; import java.util.Arrays; import com.zj.compare.Person; public class ArraysSortUnit { public static void main(String[] args) { Person[] ps = { new Person(20, "Tom" ), new Person(20, "Jeff" ), new Person(30, "Mary" ), new Person(20, "Ada" ), new Person(40, "Walton" ), new Person(61, "Peter" ), new Person(20, "Bush" ) }; System. out .println(Arrays.toString (ps)); Arrays.sort (ps); System. out .println(Arrays.toString (ps)); } } |
[20{Tom}, 20{Jeff}, 30{Mary}, 20{Ada}, 40{Walton}, 61{Peter}, 20{Bush}]
[20{Ada}, 20{Bush}, 20{Jeff}, 20{Tom}, 30{Mary}, 40{Walton}, 61{Peter}]
2.2 测试 Collections.sort ()方法
CollctionsSortUnit.java
package com.zj.sort.comparable; import java.util.Arrays; import java.util.Collections; import com.zj.compare.Person; public class CollctionsSortUnit { public static void main(String[] args) { Person[] ps = { new Person(20, "Tom" ), new Person(20, "Jeff" ), new Person(30, "Mary" ), new Person(20, "Ada" ), new Person(40, "Walton" ), new Person(61, "Peter" ), new Person(20, "Bush" ) }; System. out .println(Arrays.toString (ps)); Collections.sort (Arrays.asList (ps)); System. out .println(Arrays.toString (ps)); } } |
[20{Tom}, 20{Jeff}, 30{Mary}, 20{Ada}, 40{Walton}, 61{Peter}, 20{Bush}]
[20{Ada}, 20{Bush}, 20{Jeff}, 20{Tom}, 30{Mary}, 40{Walton}, 61{Peter}]
2.3 测试 TreeSet
TreeSetUnit.java
package com.zj.sort.comparable; import java.util.TreeSet; import com.zj.compare.Person; public class TreeSetUnit { public static void main(String[] args) { TreeSet<Person> set = new TreeSet<Person>(); set.add( new Person(20, "Tom" )); set.add( new Person(20, "Jeff" )); set.add( new Person(30, "Mary" )); set.add( new Person(20, "Ada" )); set.add( new Person(40, "Walton" )); set.add( new Person(61, "Peter" )); set.add( new Person(20, "Bush" )); System. out .println(set); } } |
[20{Ada}, 20{Bush}, 20{Jeff}, 20{Tom}, 30{Mary}, 40{Walton}, 61{Peter}]
2.4 测试 TreeMap
TreeMapUnit.java
package com.zj.sort.comparable; import java.util.TreeMap; import com.zj.compare.Person; public class TreeMapUnit { public static void main(String[] args) { TreeMap<Person, String> map = new TreeMap<Person, String>(); map.put( new Person(20, "Tom" ), "Tom" ); map.put( new Person(20, "Jeff" ), "Jeff" ); map.put( new Person(30, "Mary" ), "Mary" ); map.put( new Person(20, "Ada" ), "Ada" ); map.put( new Person(40, "Walton" ), "Walton" ); map.put( new Person(61, "Peter" ), "Peter" ); map.put( new Person(20, "Bush" ), "Bush" ); System. out .println(map); } } |
{20{Ada}=Ada, 20{Bush}=Bush, 20{Jeff}=Jeff, 20{Tom}=Tom, 30{Mary}=Mary, 40{Walton}=Walton, 61{Peter}=Peter}
转自 http://www.blogjava.net/fastunit/archive/2008/04/08/191533.html
三、Comparator和Comparable的区别
先看一下使用Comparator对User集合实现排序的方式:
import java.util.Arrays;
import java.util.Comparator;
public class UserComparator implements Comparator {
public int compare(Object o1, Object o2) {
return ((User) o1).getAge() - ((User) o2).getAge();
}
/**
* 测试方法
*/
public static void main(String[] args) {
User[] users = new User[] { new User( " a " , 30 ), new User( " b " , 20 ) };
Arrays.sort(users, new UserComparator());
for ( int i = 0 ; i < users.length; i ++ ) {
User user = users[i];
System.out.println(user.getId() + " " + user.getAge());
}
}
}
一个类实现了Camparable接口则表明这个类的对象之间是可以相互比较的,这个类对象组成的集合就可以直接使用sort方法排序。
Comparator可以看成一种算法的实现,将算法和数据分离,Comparator也可以在下面两种环境下使用:
1、类的设计师没有考虑到比较问题而没有实现Comparable,可以通过Comparator来实现排序而不必改变对象本身
2、可以使用多种排序标准,比如升序、降序等
Arrays.sort(T[], Comparator < ? super T > c) 方法用于对象数组按用户自定义规则排序.
官方Java文档只是简要描述此方法的作用,并未进行详细的介绍,本文将深入解析此方法。
1. 简单示例
sort方法的使用非常的简单明了,下面的例子中,先定义一个比较Dog大小的Comparator,然后将其实例对象作为参数传给sort方法,通过此示例,你应该能够快速掌握Arrays.sort()的使用方法。
[java] view
plain copy
import java.util.Arrays;
import java.util.Comparator;
class Dog{
int size;
public Dog(int s){
size = s;
}
}
class DogSizeComparator implements Comparator<Dog>{
@Override
public int compare(Dog o1, Dog o2) {
return o1.size - o2.size;
}
}
public class ArraySort {
public static void main(String[] args) {
Dog d1 = new Dog(2);
Dog d2 = new Dog(1);
Dog d3 = new Dog(3);
Dog[] dogArray = {d1, d2, d3};
printDogs(dogArray);
Arrays.sort(dogArray, new DogSizeComparator());
printDogs(dogArray);
}
public static void printDogs(Dog[] dogs){
for(Dog d: dogs)
System.out.print(d.size + " " );
System.out.println();
}
}
输出为:
[plain] view
plain copy
2 1 3
1 2 3
2. 使用策略模式
这是策略模式(Strategy
pattern)的一个完美又简洁的示例,值得一提的是为什么这种场景下适合使用策略模式.
总体来说,策略模式允许在程序执行时选择不同的算法.比如在排序时,传入不同的比较器(Comparator),就采用不同的算法.
根据上面的例子,假设你想要根据Dog的重量来进行排序,可以像下面这样,创建一个新的比较器来进行排序:
[java] view
plain copy
class Dog{
int size;
int weight;
public Dog(int s, int w){
size = s;
weight = w;
}
}
class DogSizeComparator implements Comparator<Dog>{
@Override
public int compare(Dog o1, Dog o2) {
return o1.size - o2.size;
}
}
class DogWeightComparator implements Comparator<Dog>{
@Override
public int compare(Dog o1, Dog o2) {
return o1.weight - o2.weight;
}
}
public class ArraySort {
public static void main(String[] args) {
Dog d1 = new Dog(2, 50);
Dog d2 = new Dog(1, 30);
Dog d3 = new Dog(3, 40);
Dog[] dogArray = {d1, d2, d3};
printDogs(dogArray);
Arrays.sort(dogArray, new DogSizeComparator());
printDogs(dogArray);
Arrays.sort(dogArray, new DogWeightComparator());
printDogs(dogArray);
}
public static void printDogs(Dog[] dogs){
for(Dog d: dogs)
System.out.print("size="+d.size + " weight=" + d.weight + " ");
System.out.println();
}
}
执行结果:
[plain] view
plain copy
size=2 weight=50 size=1 weight=30 size=3 weight=40
size=1 weight=30 size=2 weight=50 size=3 weight=40
size=1 weight=30 size=3 weight=40 size=2 weight=50
Comparator 是一个接口,所以sort方法中可以传入任意实现了此接口的类的实例,这就是策略模式的主要思想.
3. 为何使用"super"
如果使用 "Comparator < T > c" 那是很简单易懂的,但是sort的第2个参数里面的 < ? super T > 意味着比较器所接受的类型可以是T或者它的超类. 为什么是超类呢? 答案是: 这允许使用同一个比较器对不同的子类对象进行比较.在下面的示例中很明显地演示了这一点:
[java] view
plain copy
import java.util.Arrays;
import java.util.Comparator;
class Animal{
int size;
}
class Dog extends Animal{
public Dog(int s){
size = s;
}
}
class Cat extends Animal{
public Cat(int s){
size = s;
}
}
class AnimalSizeComparator implements Comparator<Animal>{
@Override
public int compare(Animal o1, Animal o2) {
return o1.size - o2.size;
}
//in this way, all sub classes of Animal can use this comparator.
}
public class ArraySort {
public static void main(String[] args) {
Dog d1 = new Dog(2);
Dog d2 = new Dog(1);
Dog d3 = new Dog(3);
Dog[] dogArray = {d1, d2, d3};
printDogs(dogArray);
Arrays.sort(dogArray, new AnimalSizeComparator());
printDogs(dogArray);
System.out.println();
//when you have an array of Cat, same Comparator can be used.
Cat c1 = new Cat(2);
Cat c2 = new Cat(1);
Cat c3 = new Cat(3);
Cat[] catArray = {c1, c2, c3};
printDogs(catArray);
Arrays.sort(catArray, new AnimalSizeComparator());
printDogs(catArray);
}
public static void printDogs(Animal[] animals){
for(Animal a: animals)
System.out.print("size="+a.size + " ");
System.out.println();
}
}
输出结果:
[plain] view
plain copy
size=2 size=1 size=3
size=1 size=2 size=3
size=2 size=1 size=3
size=1 size=2 size=3
4. 小结
与Arrays.sort()相关的信息总结如下:
通用: super 类
策略设计模式(strategy pattern);
归并排序(merge sort): 时间复杂度 n*log(n);
Java.util.Collections#sort(List < T > list, Comparator < ? super T > c)与Arrays.sort 使用类似的思想.
参考文献:
1. Arrays.sort(T[],
java.util.Comparator)
相关阅读:
Example
of Sorting Arrays
Java
Design Pattern: Strategy
Comparable
vs Comparator in Java
Top
10 Methods for Java Arrays
相关文章推荐
- PHP 程序员的技术成长规划
- java 面向对象三大特性(封装,继承,多态)以及抽象、接口的介绍
- Spark性能优化第三季
- Hibernate动态条件查询(Criteria Query)
- 转:Redis使用认证密码登录
- 戴尔PowerEdge R730 机架式服务器安装 Ubuntu 14.04.3 LTS
- 详实的SQL学习笔记
- python 套接字简单服务器端
- 通过IMAP方式迁移U-Mail邮件到Exchange 2013之2008R2 AD搭建!
- Common Lisp入门笔记(五)书后习题
- 经纬度坐标转为上海地方坐标代码(js代码)
- SHA256兼容性
- 党课心得五(杂谈)
- ThinkPHP自定义Redis处理SESSION的实现方法
- xutils使用手册(一)——初始化
- ubuntu安装python集成环境Anaconda,并搭建tensorflow学习框架
- jQuery操作select下拉框的text值和value值的方法
- scramble-string
- [bzoj1603]: [Usaco2008 Oct]打谷机 搜索
- JNI官方文档翻译1-开篇