Collections排序

Posted shawWey

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Collections排序相关的知识,希望对你有一定的参考价值。

0.前言

ThreeSet的底层实现是红黑树,它在创建set的过程中实现排序。Collections.sort是在对整个集合进行排序,按道理来说使用TreeSet插入集合元素直至建立整个TreeSet过程中实现排序在时间方面要比Collections.sort对整个集合进行排序效率要高很多,因为它在每次搜索要插入的位置时耗费的时间为log(n),n代表的是当前集合的长度,但实验表明使用Collections.sort对集合进行排序时间耗费要少些。

返回类型为int型

        Collections.sort(appIds, new Comparator<AfaApplication>() {
              @Override
              public int compare(AfaApplication app1, AfaApplication app2) {
                  if(StringUtils.isNotNullAndBlank(app1.getAppId())&&StringUtils.isNotNullAndBlank(app2.getAppId())){
                      return Integer.parseInt(app1.getAppId())-Integer.parseInt(app2.getAppId());
                  }else{
                      return 0;
                  }
              }
        });        

有时候会报错

java.lang.NumberFormatException: For input string: "006006003002"

有几种可能,有可能字段转换值超了,有可能获取的字段为空或者为null无法转为数据,这时候就要判断为空或者null

值超了和null的情况处理:

        Collections.sort(appMenuTreeList, new Comparator<AppMenuTree>() {
              @Override
              public int compare(AppMenuTree tree1, AppMenuTree tree2) {
                  if(StringUtils.isNotNullAndBlank(tree1.getTreeId())&&StringUtils.isNotNullAndBlank(tree2.getTreeId())){
                      return Long.parseLong(tree1.getTreeId())>Long.parseLong(tree2.getTreeId())?1:-1;
                  }else{
                      return 0;
                  }
              }
        });

1.性能比较

 
数据规模 循环次数 Collections.sort耗时(微妙) TreeSet耗时(微妙)
1000000 10 339332微秒 1215165微秒
100000 10 24547微秒 49862微秒
10000 10 3246微秒 3884微秒
1000 10 752微秒 1097微秒

测试机器:windows、2.2GHz、Core i5、8G

2.测试代码

package com.google.common.base;

import com.google.common.collect.Lists;
import com.google.common.primitives.Ints;
import org.junit.Test;

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


public class SortTest {
    public static final int DEFAULT_ARRAY_LENGTH = 10 * 1000 * 1000;

    private List<Integer> createList(int arrLength) {
        List<Integer> numbers = Lists.newArrayList();
        for(int i = 0; i < DEFAULT_ARRAY_LENGTH; i++) {
            numbers.add(i);
        }
        Collections.shuffle(numbers);
        return numbers;
    }
    public long testCollectionsSort(List<Integer> numbers) {
        Ticker ticker = Ticker.systemTicker();
        long startTime = ticker.read();
        Collections.sort(numbers, new Comparator<Integer>() {
            public int compare(Integer o1, Integer o2) {
                return Ints.compare(o2, o1);
            }
        });
        //long endTime = ticker.read();
        //System.out.println("[testCollectionsSort]" + (endTime - startTime) / 1000);
        //System.out.println("[testCollectionsSort]" + numbers.toString());
        return (ticker.read() - startTime) / 1000;
    }

    public long testSortedMap(List<Integer> numbers) {
        Ticker ticker = Ticker.systemTicker();
        long startTime = ticker.read();
        TreeSet<Integer> sortedNumberSet = new TreeSet<Integer>(new Comparator<Integer>() {
            public int compare(Integer o1, Integer o2) {
                return Ints.compare(o2, o1);
            }
        });
        sortedNumberSet.addAll(numbers);
        //long endTime = ticker.read();
        //System.out.println("[testSortedMap]" + (endTime - startTime) / 1000);
        //List<Integer> newNumbers = Lists.newArrayList(sortedNumberSet);
        //System.out.println("[testSortedMap]" + newNumbers.toString());
        return (ticker.read() - startTime) / 1000;
    }

    @Test
    public void testSortMethodCompare() {
        int loopCount = 10;
        long collectionsSortTimeTotalCount = 0;
        long sortedMapTimeTotalCount = 0;
        List<Integer> numbers = createList(DEFAULT_ARRAY_LENGTH);
        for(int i = 0; i < loopCount; i ++) {
            List<Integer> tempNumbers = Lists.newArrayList(numbers);//每次循环使用同样数据
            sortedMapTimeTotalCount += testSortedMap(tempNumbers);//不会改变tempNumbers
            collectionsSortTimeTotalCount += testCollectionsSort(tempNumbers);
        }
        long collectionsSortTimeCount = collectionsSortTimeTotalCount / loopCount;
        long sortedMapTimeCount = sortedMapTimeTotalCount / loopCount;
        System.out.println("[testSortMethodCompare] loopCount = " + loopCount
                + ",listSize = " + DEFAULT_ARRAY_LENGTH);
        System.out.println("[CollectinSort]" + collectionsSortTimeCount + "微秒");
        System.out.println("[SortedMapSort]" + sortedMapTimeCount + "微秒");
    }
}

3.性能差异分析

a.TreeSet每次搜索要插入的位置时耗费的时间为log(n),n代表的是当前集合的长度,n从1增加至排序的数据集合list的list.size(),这个相比Collections.sort直接对整个数据集合进行排序具有优势。

b.TreeSet一个明显的劣势排序的过程是插入新节点的过程,创建新节点,插入新节点应该也会耗费一定的时间。

c.TreeSet另一个明显的劣势为由于其底层实现为红黑树,所以每次插入后需要对原有的集合进行修改以使得新集合底层仍然是红黑树。

以上是TreeSet实现排序的优势和劣势,由性能比较数据可以看出,相比TreeSet实现排序的优势,其劣势更明显。

以上是关于Collections排序的主要内容,如果未能解决你的问题,请参考以下文章

推荐net开发cad入门阅读代码片段

初识Spring源码 -- doResolveDependency | findAutowireCandidates | @Order@Priority调用排序 | @Autowired注入(代码片段

初识Spring源码 -- doResolveDependency | findAutowireCandidates | @Order@Priority调用排序 | @Autowired注入(代码片段

java Collections.sort()实现List排序的默认方法和自定义方法

操作系统的工具类Collections

排序算法大数据量测试代码