Java实现对象排序的两种方法

这两个方法经常搞混淆，现对其进行总结以加深记忆。

1. 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>接口的组合；
2. compare(Object o1,Object o2)方法是java.util.Comparator<T>接口的方法，它实际上用的是待比较对象的compareTo(Object o)方法。

AVA中Collections.sort()实现List排序的公共方法和自定义方法

转自：http://my.oschina.net/liuyuanyuangogo/blog/151628

1.java提供的默认list排序方法

主要代码：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

List<String> list = newArrayList();

list.add("刘媛媛");

list.add("王硕");

list.add("李明");

list.add("刘迪");

list.add("刘布");

 

//升序

Collections.sort(list,Collator.getInstance(java.util.Locale.CHINA));//注意：是根据的汉字的拼音的字母排序的，而不是根据汉字一般的排序方法

for(inti=0;i<list.size();i++)

{

    System.out.print(list.get(i));

}

System.out.println("");

 

//降序

Collections.reverse(list);//不指定排序规则时，也是按照字母的来排序的

for(inti=0;i<list.size();i++)

{

     System.out.print(list.get(i));

}

输出结果：

李明刘布刘迪刘媛媛王硕
王硕刘媛媛刘迪刘布李明

 2.自定义的排序规则：

第一种是model类实现Comparable接口，重写重写int compareTo(Object o)方法

model类：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

publicclass StudentDTO implementsComparable

{

 privateString name;

 privateint age;

 

 publicString getName()

 {

    returnname;

 }

 publicvoid setName(String name)

 {

     this.name = name;

 }

 publicObjType getType()

 {

    returntype;

 }

 publicvoid setAge(intage)

 {

     this.age= age;

 }

 

 @Override

 publicint compareTo(Object o)

 {

       StudentDTO sdto = (StudentDTO)o;

       intotherAge = sdto.getAge();

       //note: enum-type's comparation depend on types' list order of enum method

      //so, if compared property is enum-type ,then its comparationfollow ObjEnum.objType order

 

      returnthis.age.compareTo(otherAge);

 }

}

主方法：           

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

publicstatic void main(String[] args)

{

      List<StudentDTO> studentList = newArrayList();

      StudentDTO s1 = newStudentDTO ();

      s.setName("yuanyuan");

      s.setAge(22);

      studentList.add(s1);

      StudentDTO s1 = newStudentDTO ();

      s.setName("lily");

      s.setAge(23);

      studentList.add(s2);

      Collections.sort(studentList); //按照age升序 22，23，

      Collections.reverse(studentList); //按照age降序 23,22  

}

通过实现Comparable接口实现个性化排序测试。排序测试，Collection.sort(list)升序排列Collections.sort(list, Collections.reverseOrder());降序排列；Collections.reverse(list);反转排序，先输出列表最后一个元素

第二种是比较器类实现Comparator接口，重写int compare(Object o1, Object o2)方法；

model类：          

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

publicclass StudentDTO implementsComparable

{

     privateString name;

     privateint age;

 

     publicString getName()

     {

         returnname;

     }

     publicvoid setName(String name)

     {

         this.name = name;

     }

     publicObjType getType()

     {

         returntype;

     }

     publicvoid setAge(intage)

     {

         this.age= age;

     }

}

比较器类：

?

1

2

3

4

5

6

7

8

9

10

11

classMyCompartor implementsComparator

{

     @Override

     publicint compare(Object o1, Object o2)

    {

           StudentDTO sdto1= (StudentDTO )o1;

           StudentDTO sdto2= (StudentDTO )o2;

 

          returnsdto1.getAge.compareTo(stdo2.getAge())//按年龄从小到大排序

//return -sdto1.getAge.compareTo(stdo2.getAge())//按年龄从大到小排序


    } 

}

主方法：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

publicstatic void main(String[] args)

{

      List<StudentDTO> studentList = newArrayList();

      StudentDTO s1 = newStudentDTO ();

      s.setName("yuanyuan");

      s.setAge(22);

      studentList.add(s1);

      StudentDTO s1 = newStudentDTO ();

      s.setName("lily");

      s.setAge(23);

      studentList.add(s2);

      MyComparetor mc = newMyComparetor();

      Collections.sort(studentList,mc);    //按照age升序 22，23

      Collections.reverse(studentList,mc);   //按照age降序 23,22 

}

附注：

1.对于数组的排序方法如下：

String[] names = {"王林",  "杨宝", "李镇", "刘迪", "刘波"};  
Arrays.sort(names, com.ibm.icu.text.Collator.getInstance(com.ibm.icu.util.ULocale.SIMPLIFIED_CHINESE));//升序;   
System.out.println(Arrays.toString(names));      

2.对于汉字的排序：可以尝试使用ICU4J会得到更好的结果，特别是姓为某些生僻字的时候，

用com.ibm.icu.text.Collator替换java.text.Collator，用com.ibm.icu.util.ULocale替换java.util.Locale

3.对于枚举类型的enum1.compareTo（enum2）是按照枚举类型值在定义时的先后顺序比较的，越后面的越大，而不是按照值的字母先后顺序比较的。

java实现对象比较，可以实现java.lang.Comparable或java.util.Comparator接口

//Product.java

import java.util.Date;

//public class Product implements Comparable {//类内比较
public class Product{

    private String name;
    private Date date;
    private int price;

    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Date getDate() {
        return date;
    }
    public void setDate(Date date) {
        this.date = date;
    }

//用于类内比较
//  @Override//覆写compareTo(Object o)方法
//  public int compareTo(Product o) {
//      return -this.date.compareTo(o.date);
//  }

}

//ProductComparable.java

import java.util.Date;
import java.util.Comparator;

public class ProductComparable implements Comparator<Product> {

    // 对象的排序方式[升、降]
    public static boolean sortASC = true;

    // 对象的排序属性
    public static boolean sortByName = false;
    public static boolean sortByDate = false;
    public static boolean sortByPrice = false;


    @Override
    public int compare(Product pro1, Product pro2) {

        int result = 0;

        if(sortASC){
            if(sortByName){
                String pro1name = pro1.getName();
                String pro2name = pro2.getName();
                result = pro1name.compareTo(pro2name);
            }else if(sortByDate){
                Date pro1Date = pro1.getDate();
                Date pro2Date = pro2.getDate();

                result = pro1Date.compareTo(pro2Date);

            }else if(sortByPrice){
                Integer pro1Price = pro1.getPrice();
                Integer pro2Price = pro2.getPrice();

                result = pro1Price.compareTo(pro2Price);
            }
        }else{
            if(sortByName){
                String pro1name = pro1.getName();
                String pro2name = pro2.getName();

                result =  -pro1name.compareTo(pro2name);
            }else if(sortByDate){
                Date pro1Date = pro1.getDate();
                Date pro2Date = pro2.getDate();

                result =  -pro1Date.compareTo(pro2Date);

            }else if(sortByPrice){
                Integer pro1Price = pro1.getPrice();
                Integer pro2Price = pro2.getPrice();

                result =  -pro1Price.compareTo(pro2Price);
            }
        }
        return result;
    }

}

//测试代码

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;

public class ProductSort {

    public static void main(String[] args) throws ParseException {
        Product pro1 = new Product();
        pro1.setName("pro1");
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-dd-MM",Locale.CHINA);
        pro1.setDate(sdf.parse("2009-03-23"));
        pro1.setPrice(89);
        Product pro2 = new Product();
        pro2.setName("proc2");
        pro2.setDate(sdf.parse("2009-02-23"));
        pro2.setPrice(45);
        Product pro3 = new Product();
        pro3.setName("proc3");
        pro3.setDate(sdf.parse("2009-01-23"));
        pro3.setPrice(83);
        Product pro4 = new Product();
        pro4.setName("proc4");
        pro4.setDate(sdf.parse("2009-01-23"));
        pro4.setPrice(800);


        List<Product> productList = new ArrayList<Product>();
        productList.add(pro1);
        productList.add(pro3);
        productList.add(pro2);
        productList.add(pro4);

        System.out.println("排序前————————————————————");
        for(Product p: productList){
            System.out.println(p.getName()+"----"+p.getPrice()+"----"+p.getDate());
        }
        ProductComparable sort = new ProductComparable();

        ProductComparable.sortASC = false;//降序
        ProductComparable.sortByPrice=true;  //设置排序属性生效
        Collections.sort(productList,sort);

        System.out.println("排序后————————————————————");

        for(Iterator<Product>  iter = productList.iterator(); iter.hasNext();){
            Product p = (Product)iter.next();
            System.out.println(p.getName()+"----"+p.getPrice()+"---"+p.getDate());
        }
    }
}

 推荐使用Comparator实现排序

因为 你用一个第三方的类，但他没实现Comparable接口，而你又不能改他代码；另外，类一旦写好后是不允许修改的，但可以扩展，所以只能用Comparator接口