java排序之Collections.sort()和Arrays.sort()用法詳解

注：Collections.sort()和Arrays.sort()排序是按ASCII碼進行排序的，關於ASCII碼相關的可自行百度，String字符串和ASCII之間的轉化可參考

https://www.cnblogs.com/damoblog/p/14386269.html。

一、Collections.sort()排序

    1. 若需要排序的元素實現了Comparable接口，則可以直接使用Colletions.sort()或者Arrays.sort()進行排序,其中源碼Collections.class,如下

public static <T extends Comparable<? super T>> void sort(List<T> paramList) { paramList.sort(null); }

此外，"實現了Comparable接口的類的對象"可以用作"有序映射(如TreeMap)"中的鍵或"有序集合(TreeSet)"中的元素，而不需要指定比較器。

代碼案列：

package com.itheima.course.collection;

/**
 * @description 實現了Comparable接口的類
 * @author ...
 * @date 2021-02-07 16:58:25
 */
public class SortA implements Comparable<SortA> {
    private String name;
    private Integer order;

    /**
     * @return the name
     */
    public String getName() {
        return name;
    }

    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * @return the order
     */
    public Integer getOrder() {
        return order;
    }

    /**
     * @param order the order to set
     */
    public void setOrder(Integer order) {
        this.order = order;
    }

    @Override
    public String toString() {
        return "SortA [name=" + name + ", order=" + order + "]";
    }

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

/**
 * 
 */
package com.itheima.course.collection;

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

/**
 * @description 測試類
 * @author ...
 * @date 2021-02-07 17:11:07
 */
public class SortATest {
    public static void main(String[] args) {
        // String 排序
        List<String> lists = new ArrayList<String>();
        lists.add("5");
        lists.add("2");
        lists.add("9");
        // lists中的對象String 本身含有compareTo方法，所以可以直接調用sort方法，按自然順序排序，即升序排序
        Collections.sort(lists);
        System.out.println("String 排序后: " + lists.toString());
        // 結果 String 排序后: [2, 5, 9]

        // 第一種方法示例：
        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("排序后: " + listA);
        // 結果排序后: [SortA [name=b, order=1], SortA [name=a, order=2], SortA [name=c,
        // order=5]]
    }

}

2. 若需要排序的元素未實現Comparable接口，則我們可使用Comparator 比較器接口。

    我們若需要控制某個類的次序，而該類本身不支持排序(即沒有實現Comparable接口)；那么，我們可以建立一個“比較器”來進行排序。這個“比較器”只需要實現Comparator接口即可。也就是說，我們可以通過“實現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.itheima.course.collection;

/**
 * @description 實體類
 * @author ...
 * @date 2021-02-07 17:16:12
 */
public class SortB {
    private String name;
    private Integer order;

    /**
     * @return the name
     */
    public String getName() {
        return name;
    }

    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * @return the order
     */
    public Integer getOrder() {
        return order;
    }

    /**
     * @param order the order to set
     */
    public void setOrder(Integer order) {
        this.order = order;
    }

    @Override
    public String toString() {
        return "SortB [name=" + name + ", order=" + order + "]";
    }

}

/**
 * 
 */
package com.itheima.course.collection;

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

/**
 * @description SortB測試類
 * @author ...
 * @date 2021-02-07 17:18:09
 */
public class SortBTest {
    public static void main(String[] args) {
        // 示例：
        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);
        Collections.sort(listA, new Comparator<SortA>() {
            public int compare(SortA s1, SortA s2) {
                /**
                 * 升序排的話就是第一個參數.compareTo(第二個參數); 降序排的話就是第二個參數.compareTo(第一個參數);
                 */
                return s2.getOrder().compareTo(s1.getOrder());
            }
        });
        System.out.println("降序排序后: " + listA.toString());
        // 結果
        // 降序排序后: [SortA [name=c, order=5], SortA [name=a, order=2], SortA [name=b, order=1]]
    }
}

二、Collections.sort()和Arrays.sort()排序案列

package com.itheima.course.collection;

import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeSet;

/**
 * @description 測試主類
 * @author ...
 * @date 2021-02-03 08:43:19
 */
public class TestMain {

    /**
     * 按ASCII碼升序排序 Arrays.sort
     * 
     * @param data 待排序數據
     * @return 排序后數據
     */
    public static String arraysSort(final Map<String, String> data) {
        Set<String> keySet = data.keySet();
        String[] keyArray = keySet.toArray(new String[keySet.size()]);
        Arrays.sort(keyArray);
        // 構造URL 鍵值對的格式
        StringBuilder sb = new StringBuilder();
        for (String k : keyArray) {
            // 參數值為空，則不參與簽名
            if (data.get(k).trim().length() > 0) {
                sb.append(k).append("=").append(data.get(k).trim()).append("&");
            }
        }
        if (sb.length() > 0) {
            sb.deleteCharAt(sb.length() - 1);
        }
        return sb.toString();
    }

    /**
     * 按ASCII碼降序排序 Collections.sort
     * 
     * @param data 待排序數據
     * @return 排序后數據
     */
    public static String collectionssSort1(final Map<String, String> data) {
        Set<String> keySet = data.keySet();
        String[] keyArray = keySet.toArray(new String[keySet.size()]);
        List<String> keyList = Arrays.asList(keyArray);
        Collections.sort(keyList, new Comparator<String>() {
            @Override
            public int compare(String paramT1, String paramT2) {
                return paramT2.compareTo(paramT1);
            }
        });
        // 構造URL 鍵值對的格式
        StringBuilder sb = new StringBuilder();
        for (String k : keyArray) {
            // 參數值為空，則不參與簽名
            if (data.get(k).trim().length() > 0) {
                sb.append(k).append("=").append(data.get(k).trim()).append("&");
            }
        }
        if (sb.length() > 0) {
            sb.deleteCharAt(sb.length() - 1);
        }
        return sb.toString();
    }

    /**
     * 按ASCII碼降序排序 Collections.sort
     * 
     * @param data 待排序數據
     * @return 排序后數據
     */
    public static String collectionssSort2(final Map<String, String> data) {
        List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>(data.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<String, String>>() {
            @Override
            public int compare(Entry<String, String> paramT1, Entry<String, String> paramT2) {
                return (paramT1.getKey()).toString().compareTo(paramT2.getKey());
            }
        });
        // 構造URL 鍵值對的格式
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<String, String> item : list) {
            String key = item.getKey();
            String value = item.getValue();
            // 參數值為空，則不參與簽名
            if (value != null && (!"".equals(value.trim()))) {
                sb.append(key).append("=").append(value.trim()).append("&");
            }
        }
        if (sb.length() > 0) {
            sb.deleteCharAt(sb.length() - 1);
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        Map<String, String> sortMap = new HashMap<String, String>();
        sortMap.put("zx", "123");
        sortMap.put("zz", "456");
        sortMap.put("aa", "789");
        // 按ASCII碼升序排序
        System.out.println(arraysSort(sortMap));
        System.out.println("按ASCII碼降序排序 Collections.sort: " + collectionssSort1(sortMap));
        System.out.println("按ASCII碼降序排序 Collections.sort: " + collectionssSort2(sortMap));
        /*
         * 結果: 
         * aa=789&zx=123&zz=456
         * zz=456&zx=123&aa=789
         * aa=789&zx=123&zz=456
         */

// 目的: 比較器Comparator的
        @SuppressWarnings(value = { "unused" })
        Comparator<Integer> comp = new Comparator<Integer>() {
            @Override
            public int compare(Integer paramT1, Integer paramT2) {
                return paramT1 - paramT2;
            }
        };
        Set<Integer> set = new TreeSet<Integer>(comp);
        set.add(33);
        set.add(10);
        set.add(55);
        System.out.println(set);

    }
}