Java中Collections.sort()排序詳解

 　　

public static void main(String[] args) {
　　List<String> list = new ArrayList<String>();
　　list.add("beijing");
　　list.add("shanghai");
　　list.add("hangzhou");
　　Collections.sort(list, new Comparator<String>() {
　　　　　　public int compare(String str1, String str2) {

　　　　　　/**
　　　　　　* 升序排的話就是第一個參數.compareTo(第二個參數);
　　　　　　* 降序排的話就是第二個參數.compareTo(第一個參數);
　　　　　　*/

　　　　　　// 按首字母升序排
　　　　　　// return str1.compareTo(str2);
　　　　　　// 按第二個字母升序排
　　　　　　char c1 = str1.charAt(1);
　　　　　　char c2 = str2.charAt(1);
　　　　　　return c1 - c2;
　　　　}
　　});
　　System.out.println(list);
}

 

第一種：Comparable 排序接口
若一個類實現了Comparable接口，就意味着「該類支持排序」。 假設「有一個List列表(或數組)，裏面的元素是實現了Comparable接口的類」，則該List列表(或數組)能夠經過 Collections.sort（或 Arrays.sort）進行排序。

此外，「實現Comparable接口的類的對象」能夠用做「有序映射(如TreeMap)」中的鍵或「有序集合(TreeSet)」中的元素，而不須要指定比較器。

/*實體類*/
package com.hou.test1;

public class SortA implements Comparable<SortA> {
	
	private String name;
    private Integer order;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getOrder() {
        return order;
    }

    public void setOrder(Integer order) {
        this.order = order;
    }

    @Override
    public String toString() {
        return "name:" + name + "--order:" + order;
    }

	@Override
	public int compareTo(SortA a) {
//		 return a.getOrder()-this.order; //升序
//		return this.order-a.getOrder(); //倒序
//		return this.order.compareTo(a.getOrder());//升序
		return a.getOrder().compareTo(this.order);//倒序
	}


}


/*測試類*/
package com.hou.test1;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class SortTest {

	public static void main(String[] args) {
		//第一種方法示例：
        List<String> lists = new ArrayList<String>();
        lists.add("5");
        lists.add("2");
        lists.add("9");
        //lists中的對象String 自己含有compareTo方法，因此能夠直接調用sort方法，按天然順序排序，即升序排序
        Collections.sort(lists);

        //第一種方法示例：
        List<SortA> listA = new ArrayList<SortA>();
        SortA a1 = new SortA();
        a1.setName("a");
        a1.setOrder(2);
        SortA a2 = new SortA();
        a2.setName("b");
        a2.setOrder(1);
        SortA a3 = new SortA();
        a3.setName("c");
        a3.setOrder(5);
        listA.add(a1);
        listA.add(a2);
        listA.add(a3);
        //list中的對象A實現Comparable接口
        Collections.sort(listA);
        
        System.out.println(lists);
        System.out.println(listA);

	}

}

/*輸出結果*/
[2, 5, 9]
[name:c--order:5, name:a--order:2, name:b--order:1]

　　

 

第二種：Comparator比較器接口。
咱們若須要控制某個類的次序，而該類自己不支持排序(即沒有實現Comparable接口)；咱們能夠創建一個「比較器」來進行排序。這個「比較器」只須要實現Comparator接口便可。

Collections.sort(list, new PriceComparator())

參數一：須要排序的list
參數二：比較器，實現Comparator接口的類，返回一個int型的值，就至關於一個標誌，告訴sort方法按什麼順序來對list進行排序。
Comparator是個接口，可重寫compare()及equals()這兩個方法,用於比較功能；若是是null的話，就是使用元素的默認順序，如a,b,c,d,e,f,g，就是a,b,c,d,e,f,g這樣，固然數字也是這樣的。

compare（a,b）方法:根據第一個參數小於、等於或大於第二個參數分別返回負整數、零或正整數。
equals（obj）方法：僅當指定的對象也是一個 Comparator，而且強行實施與此 Comparator 相同的排序時才返回 true。
/*實體類*/
package com.hou.test1;

public class SortA  {
	
	private String name;
    private Integer order;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getOrder() {
        return order;
    }

    public void setOrder(Integer order) {
        this.order = order;
    }

    @Override
    public String toString() {
        return "name:" + name + "--order:" + order;
    }



}

/*測試類*/
package com.hou.test1;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class SortTest {

	public static void main(String[] args) {
		//第一種方法示例：
        List<String> lists = new ArrayList<String>();
        lists.add("5");
        lists.add("2");
        lists.add("9");
        //lists中的對象String 自己含有compareTo方法，因此能夠直接調用sort方法，按天然順序排序，即升序排序
        Collections.sort(lists);

        //第一種方法示例：
        List<SortA> listA = new ArrayList<SortA>();
        SortA a1 = new SortA();
        a1.setName("a");
        a1.setOrder(2);
        SortA a2 = new SortA();
        a2.setName("b");
        a2.setOrder(1);
        SortA a3 = new SortA();
        a3.setName("c");
        a3.setOrder(5);
        listA.add(a1);
        listA.add(a2);
        listA.add(a3);
        //list中的對象A實現Comparable接口
        //Collections.sort(lists);
        Collections.sort(listA, new Comparator<SortA>() {
        	public int compare(SortA s1, SortA s2) {
                /**
                 * 升序排的話就是第一個參數.compareTo(第二個參數);
                 * 降序排的話就是第二個參數.compareTo(第一個參數);
                 */
        		return s2.getOrder().compareTo(s1.getOrder());
            }
		
		});
        
        System.out.println(lists);
        System.out.println(listA);

	}

}

/*結果輸出*/
[2, 5, 9]
[name:c--order:5, name:a--order:2, name:b--order:1]