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);

    }
}