java compare 接口

1.比较后,返回0,1,-1 的结果,可以用

   return (thisVal<anotherVal ? -1 : (thisVal==anotherVal ? 0 : 1));

效率更高

 

以下转自 http://bluelzx.javaeye.com/blog/200987

 

 

1. 两种比较接口分析
集合框架 中有两种比较接口: Comparable 接口和 Comparator 接口。 Comparable 是通用的接口,用户可以实现它来完成自己特定的比较,而 Comparator 可以看成一种算法的实现,在需要容器集合实现比较功能的时候,来指定这个比较器,这可以看成一种设计模式,将算法和数据分 离。
前者应该比较固 定,和一个具体类相绑定,而后者比较灵活,它可以被用于各个需要比较功能的类使用。
一个类实现了 Camparable 接口表明这个类的对象之间是可以相互比较的。如果用数学语言描述的话就是这个类的对象组成的集合中存在一个全序。这样,这 个类对象组成的集合就可以使用 Sort 方法排序了。
Comparator 的作用有两个:
1 、如果类的设计师没有考虑到 Compare 的问题而没有实现 Comparable 接口,可以通过 Comparator 来实现比较算法进行排序;
2 、为了使用不同的排序标准做准备,比如:升序、降序或其他什么序。
2 Comparable 接口
public interface Comparable<T> {
    public int compareTo(T o);
}
java.lang. Comparable 接口定义类的自然顺序,实现该接口的类就可以按这种方式排序。  
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 值排序
利用 Comparable 接口创建自己的类的排序顺序,只是实现 compareTo() 方法的问题。通常就是依赖几个数据成员的自然排序。同时类也应该覆盖 equals() hashCode() 以确保两个相等的对象返回同一个哈希码。
这个接口的作 用:如果数组或者集合中的(类)元素实现了该接口的话 , 我们就可以调用 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 + "}" );
    }
}
2.1 测试 Arrays.sort ()方法
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、可以使用多种排序标准,比如升序、降序等

 

阅读更多
个人分类: JAVA
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭