集合常用的排序方法之单元素集合篇

常用的集合类无非是List、Set，及其他们的子类，其中List从jdk1.8开始是内置了排序方法的，且需要传入一个比较器作为参数；

单元素指的的是 基础类型的引用类，String
如：List<Integer>、List<Stirng>、Set<Integer>、Set<String>

1）对于List来说，直接用内置排序即可

定义一个list集合：

List<Integer> list = new ArrayList<>();
        list.add(22);
        list.add(1);
        list.add(2);
        list.add(12);
        list.add(52);

        list.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //升序
                return o1.compareTo(o2);
                //降序
//                return o2.compareTo(o1);
            }
        });

注意：注释中的升序降序代码及解释

List 也可以使用流（Stream）的排序：

System.out.println(list.parallelStream().sorted().collect(Collectors.toList()));

2）对于Set，有两种方式：

首先新建一个set集合：

Set<Integer> set = new HashSet<>();
        set.add(22);
        set.add(1);
        set.add(2);
        set.add(12);
        set.add(52);

第一种：使用工具类Collections的排序，Collections的排序还是调用List的内置排序，所以需要把set转为list集合：

//转为list集合
List<Integer> list1 = Arrays.asList(set.toArray(new Integer[set.size()]));
//排序，降序
Collections.sort(list1);
//输出结果
System.out.println(list1);

降序需要重写compareTo方法：

        //转为list集合
        List<Integer> list1 = Arrays.asList(set.toArray(new Integer[set.size()]));
        //排序，降序
        Collections.sort(list1, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2.compareTo(o1);
//                 若写成 return o1.compareTo(o2); 结果跟默认排序一样，升序
            }
        });
        //输出结果
        System.out.println(list1);

第二种：使用流（Stream）中的排序方法：

流的排序不传参时也是默认升序，

System.out.println(set.parallelStream().sorted().collect(Collectors.toList()));

注意代码中划红线的地方，必须要用toList()，不然排序不起作用。
反例如下图：

使用流时的降序，需要重写Comparator类的compareTo() 方法：

System.out.println(set.parallelStream().sorted(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2.compareTo(o2);
            }
        }).collect(Collectors.toList()));

效果图如下：

这里总结一下Stream的排序跟List内置的排序处理的区别：

1）最大的一个区别是，Stream是对目标集合的深度复制的数据进行排序然后返回一个新的集合，对目标集合没有任何影响；而List内置的排序是直接操作的目标集合，直接将目标进行排序，不会生成新的集合。
2）另一个是，使用流排序，还可以开启并行流（parallelStream），在数据量多的时候能够大大提升性能。
ps：建议使用流的排序。

上面介绍的工具类都是基于在JDK8（含）之后的版本才支持的；

JDK8之前还有另一种排序方式，即转为数组，利用Arrays的排序，然后再转为list：

//先转为数组
Integer[] array = list.toArray(new Integer[list.size()]);
//再排序
Arrays.sort(array);
//最后再转为集合
System.out.println(Arrays.asList(array));

效果图：