Java基础之List内元素的排序性能对比

一、概述

在日常开发中，获取一批数据后，可能需要跟据一定规则对这批数据进行排序操作。在JAVA中，动态数组ArrayList经常被用来存储数据，因此如何高效对ArrayList中元素进行排序，形成符合条件的数据集是日常开发必须要考虑的问题。本文将分析常用ArrayList排序的几种方式，包括集合框架提供的Collections.sort方法、实现Comparable接口、以及JAVA 8 stream流中提供的排序方法，同时对比同一条件不同数据集大小的排序性能。

二、按条件排序几种方案及性能对比

2.1 利用集合框架提供的Collections.sort实现排序

private ArrayList<StreamConfig> testCollectionSort(ArrayList<StreamConfig> lists) {
       Collections.sort(lists, new Comparator<StreamConfig>() {
           @Override
           public int compare(StreamConfig s1, StreamConfig s2) {
               return s2.getLostThreshold() - s1.getLostThreshold();
           }
       });
       return lists;
   }

@Data
@ToString
public class StreamConfig {

/**
    * 主键
    */
   private Long id;

/**
    * 分片检测(检测阈值)
    */
   private Integer detectRate;

/**
    * 上报阈值
    */
   private Integer lostThreshold;

/**
    * 上报周期(单位:秒)
    */
   private Integer reportRate;

/**
    * 创建时间
    */
   private Date createTime;

/**
    * 修改时间
    */
   private Date modifyTime;
}

long startTime = System.currentTimeMillis();
   log.info("Collection.sort 排序开始时间为：{}", System.currentTimeMillis());
   ArrayList<StreamConfig> list = testCollectionSort(lists);
   long endTime = System.currentTimeMillis();
   log.info("Collection.sort 耗费总时间为：{} ms", endTime - startTime);

2.2 实现Comparable接口

@Data
@ToString
public class StreamConfig implements Comparable<StreamConfig>{

/**
    * 主键
    */
   private Long id;

/**
    * 分片检测(检测阈值)
    */
   private Integer detectRate;

/**
    * 上报阈值(丢失率大于多少不再上报)
    */
   private Integer lostThreshold;

/**
    * 上报周期(单位:秒)
    */
   private Integer reportRate;

/**
    * 创建时间
    */
   private Date createTime;

/**
    * 修改时间
    */
   private Date modifyTime;

/**
    * 备注
    */
   private String remark;

/**
    * nodeCode
    */
   private String nodeCode;

/**
    * 流媒体Id
    */
   private String unitId;

@Override
   public int compareTo(StreamConfig o) {
       return this.getLostThreshold() - o.getLostThreshold();
   }
}

long comparableStartTime = System.currentTimeMillis();
       Collections.sort(list3);
       long comparableEndTime = System.currentTimeMillis();
       log.info("Comparable 耗费总时间为：{}", comparableEndTime - comparableStartTime);

2.3 利用JAVA 8 stream流实现排序

long streamStartTime = System.currentTimeMillis();
       log.info("java 8 stream流式处理开启：{}", streamStartTime);
       List<StreamConfig> collect = list2.stream().sorted(Comparator.comparing(StreamConfig::getLostThreshold)).collect(Collectors.toList());
       log.info("java 8 stream流式所花时间为：{} ms", System.currentTimeMillis() - streamStartTime);

2.4 性能对比

测试方案：

为了防止Collection.sort与实现Comparable接口两种方法的相互干扰，将实现Comparable的方案单独测试，数据量集分别为1000、10000、100000，结果单位为毫秒(ms)，每个数据集测试五次，取平均值。

测试代码如下：

public String test() {
       ArrayList<StreamConfig> lists = new ArrayList<>(100000);
       for (int i = 0; i < 100000; i++) {
           StreamConfig streamConfig = new StreamConfig();
           streamConfig.setReportRate((int) (Math.random() * 10000));
           streamConfig.setLostThreshold((int) (Math.random() * 100000));
           streamConfig.setDetectRate((int) (Math.random() * 10000));
           streamConfig.setCreateTime(randomDate("2019-01-01", "2021-05-31"));
           streamConfig.setId(System.currentTimeMillis() + (int) (Math.random() * 100000));
           lists.add(streamConfig);
       }
       ArrayList<StreamConfig> list2 = new ArrayList<>(lists);
       ArrayList<StreamConfig> list3 = new ArrayList<>(lists);
       long startTime = System.currentTimeMillis();
       log.info("Collection.sort 排序开始时间为：{}", System.currentTimeMillis());
       ArrayList<StreamConfig> list = testCollectionSort(lists);
       long endTime = System.currentTimeMillis();
       log.info("Collection.sort 耗费总时间为：{} ms", endTime - startTime);

log.info("Comparable 排序开始时间为：{}", System.currentTimeMillis());
       long comparableStartTime = System.currentTimeMillis();
       Collections.sort(list3);
       long comparableEndTime = System.currentTimeMillis();
       log.info("Comparable 耗费总时间为：{}", comparableEndTime - comparableStartTime);

long streamStartTime = System.currentTimeMillis();
       log.info("java 8 stream流式处理开启：{}", streamStartTime);
       List<StreamConfig> collect = list2.stream().sorted(Comparator.comparing(StreamConfig::getLostThreshold).reversed()).collect(Collectors.toList());
       log.info("java 8 stream流式处理结束：{}", System.currentTimeMillis());
       log.info("java 8 stream流式所花时间为：{} ms", System.currentTimeMillis() - streamStartTime);
       return "success";
   }

测试结果如下：

三、小结

1.由测试结果来看，在数据量分别是1000、10000、100000的数据集下，java 8 stream的排序方案所花费时间远大于Collection.sort方案和实现Comparable接口方案；

2.由测试结果来看，Collection.sort方案和实现Comparable接口方案在数据量越大所花费的时间越接近，这两种方案在数据量相同时的差异也不是很大；

3.本文所对比的是单条件下(也就是跟据lostThreshold属性值进行对比)，多条件可能会略有差异，后续可针对多条件进行一些数据测试与验证；

4.由测试结果可以得出，单条件对比时，Collection.sort方案和实现Comparable接口方案具有更高性能，建议数据量较大时尽量采用这两种排序方式。

来源：https://blog.csdn.net/qq_33479841/article/details/116157445