Java 中对 集合 排序的两种方式

　　在对于 Java 中进行集合 排序时，一般用到 Collections 工具类，它提供了很多方便我们操作集合的方法，其中就包括了集合的排序方法：

 

 

 一、基本类型的比较：

　　此处示例 字符串集合 和 整数集合 排序：

@Test
public void testjichuSort() {
    List<String> strList = new ArrayList<>();
    strList.add("15");
    strList.add("12");
    strList.add("18");
    // 字符串排序
    Collections.sort(strList);
    /*strList.sort(new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            return o2.compareTo(o1);
        }
    });*/
    System.out.println("*******字符串排序********");
    for (String s : strList) {
        System.out.println(s);
    }
    List<Integer> intList = new ArrayList<>();
    intList.add(15);
    intList.add(12);
    intList.add(18);
    intList.add(8);
    Collections.sort(intList);
    System.out.println("*************整数类型排序***********");
    for (Integer integer : intList) {
        System.out.println(integer);
    }
}

　　结果为：

 　   为什么基础类型的集合，可以直接调用 sort 排序，而不需要重新 实现 Comparable 接口类？

　　由Collections.sort() 方法源代码可知：

 　　调用该 sort() 方法的前提条件时，该集合 list 的类型 T 必须实现  Comparable 才行；

　　但是 基础类型 都默认继承了  Comparable 类，所以可以直接使用 sort 方法：

 二、对于集合中的对象的比较 (根据对象的某些属性来排序):

　　由于不是基础类型，从 Collections.sort() 的方法源码可知，需要重写一个 实现 comparator 接口的类，类中实现定义排序的方法才行:

 　　对象类定义：SortObject.java:

?

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 34 35 36 37 38 39 40

package com.example.test;   public class SortObject {       private String name;       private Integer number;       public SortObject() {     }       public SortObject(String name, Integer number) {         this.name = name;         this.number = number;     }       public String getName() {         return name;     }       public void setName(String name) {         this.name = name;     }       public Integer getNumber() {         return number;     }       public void setNumber(Integer number) {         this.number = number;     }       @Override     public String toString() {         return "SortObject{" +                 "name='" + name + '\'' +                 ", number=" + number +                 '}';     } }

　　比较方法，及其实现 Comparator 接口的 实现类：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

@Test public void testObjectSort() {     List<SortObject> objectList = new ArrayList<>();     objectList.add(new SortObject("D1", 1));     objectList.add(new SortObject("C1", 2));     objectList.add(new SortObject("B1", 3));     objectList.add(new SortObject("A1", 4));     // 此处 实例化一个 自定义并实现 Comparator 接口的 实例类     Collections.sort(objectList, new comparatorObject());     for (SortObject sortObject : objectList) {         System.out.println(sortObject.toString());     } }   // 实现 Comparator 接口，并实现该接口的 compare 方法的类 class comparatorObject implements Comparator<SortObject> {     @Override     public int compare(SortObject o1, SortObject o2) {         return o1.getName().compareTo(o2.getName());     } }

　　运行结果为：

三、采用匿名内部类的方式(常用)：(不分基础类还是对象类)

　　使用范围：

• 对于基础类来说，想自定义排序方式；
• 对于对象类来说，不用每次比较都要手动创建一个实体类来重写比较方法；

　　在 二 代码的基础上：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

@Test     public void testSortByCustom() {         List<SortObject> objectList = new ArrayList<>();         objectList.add(new SortObject("D1", 1));         objectList.add(new SortObject("C1", 2));         objectList.add(new SortObject("B1", 3));         objectList.add(new SortObject("A1", 4));         // 采用 匿名内部类的 方式，自定义排序         Collections.sort(objectList, new Comparator<SortObject>() {             @Override             public int compare(SortObject o1, SortObject o2) {                 // 正序 //                return o1.getName().compareTo(o2.getName());                 // 倒序                 return o2.getName().compareTo(o1.getName());             }         });         for (SortObject sortObject : objectList) {             System.out.println(sortObject.toString());         }     }

　　结果为：

 

 

 

　　总结：

• 在 字符串 集合的排序中，一般默认的排序都是按照每个 字符串的长度来一一比较，如果字符串长度不一致的话，会导致意外的排序结果；为了避免这种情况，一般采用自定义的排序，重写排序的判断逻辑；
• 基础类排序，可以直接使用 sort() ；
• 对象类排序，建议使用匿名内部类的方式自定义排序方式