【java】java常用排序方法效率比较

先从实际业务中出发，我用的较多的是java中的collections工具类，里面有两种排序方法

直接上代码验证

1、Collections内的sort方法

    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            list.add(new Random().nextInt(100));
        }
        int method = 1;
//        方法1：Collections内的sort方法
        if (method == 1) {
            System.out.println("排序前" + list);
            long startTime = System.currentTimeMillis();
            Collections.sort(list);
            long endTime = System.currentTimeMillis();
            long timeDifference = endTime - startTime;
            System.out.println("***********************************************************");
            System.out.println("用时：【" + timeDifference + "】毫秒");
            System.out.println("排序后" + list);
        }

随机生成100个随机数，用时1ms

看来100个数太少了，上到100W，结果用时440ms

2、Collections内的sort方法，重写compareable方法

        if (method == 2) {
            System.out.println("排序前" + list);
            long startTime = System.currentTimeMillis();
            Collections.sort(list, new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    return o1 - o2;
                }
            });
            long endTime = System.currentTimeMillis();
            long timeDifference = endTime - startTime;
            System.out.println("***********************************************************");
            System.out.println("用时：【" + timeDifference + "】毫秒");
            System.out.println("排序后" + list);
        }

注意注释掉打印集合（只是用于验证是否成功排序），不然看不到用时，结果用时507ms

IDEA提示这段代码可以优化，按提示方法2代码变成下面这样

变化1:

测试用时：585ms，尴尬，时间反倒变长了，这是什么鬼？

变化2：

测试用时：670ms，都是重写comparable方法，代码虽然省略，但调用的复杂程度提高了。

2、排序算法

常用的有冒泡、选择、插入等，根据实际业务场景选择，详细算法可以参考，里面罗列了各算法的动图，十分有助于新手理解。
算法总结

https://www.cnblogs.com/guoyaohua/p/8600214.html

由于排序算法由数组展示的效果更好，所以此处将list转成了数组，顺便安利一波list与array互转方法

List<String> list = Arrays.asList(arr);
String[] array= list .toArray();

（1）冒泡排序

• 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
• 针对所有的元素重复以上的步骤，除了最后一个；
• 重复步骤1~3，直到排序完成。
  

//        方法3：冒泡排序
        if (method == 3) {
            Integer[] array = list.toArray(new Integer[list.size()]);
            long startTime = System.currentTimeMillis();
            for (int i = 0; i < list.size(); i++) {
                for (int j = 0; j < array.length - 1 - i; j++) {
                    if (array[j + 1] < array[j]) {
                        int temp = array[j + 1];
                        array[j + 1] = array[j];
                        array[j] = temp;
                    }
                }
            }
            long endTime = System.currentTimeMillis();
            long timeDifference = endTime - startTime;
            System.out.println("***********************************************************");
            System.out.println("用时：【" + timeDifference + "】毫秒");
        }

等了很久一直在运行

相比大家猜也猜到了，我的集合有100W个数，根据冒泡算法原理，每个数都要去跟其他数一一对比，那要算到啥时候去了，所以这里将100W改成1W，再次运行，结果684ms，运行之前方法1、2分别得到【0ms】、【133ms】，没看错，方法1collections的sort方法还补到1ms。

（2）选择排序
它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

//        方法4：选择排序
        if (method == 4) {
            long startTime = System.currentTimeMillis();
            for (int i = 0; i < array.length; i++) {
                int minIndex = i;
                for (int j = i; j < array.length; j++) {
//              找到最小的数
                    if (array[j] < array[minIndex]) {
//                  将最小数的索引保存
                        minIndex = j;
                    }
                }
                int temp = array[minIndex];
                array[minIndex] = array[i];
                array[i] = temp;
            }
            long endTime = System.currentTimeMillis();
            long timeDifference = endTime - startTime;
            System.out.println("***********************************************************");
            System.out.println("用时：【" + timeDifference + "】毫秒");
        }

运行结果，191ms

（3）插入排序

• 从第一个元素开始，该元素可以认为已经被排序；
• 取出下一个元素，在已经排序的元素序列中从后向前扫描；
• 如果该元素（已排序）大于新元素，将该元素移到下一位置；
• 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
• 将新元素插入到该位置后；
• 重复步骤2~5。
  

//        方法5：插入排序
        if (method == 5) {
            long startTime = System.currentTimeMillis();
            int current;
            for (int i = 0; i < array.length - 1; i++) {
                current = array[i + 1];
                int preIndex = i;
                while (preIndex >= 0 && current < array[preIndex]) {
                    array[preIndex + 1] = array[preIndex];
                    preIndex--;
                }
                array[preIndex + 1] = current;
            }
            long endTime = System.currentTimeMillis();
            long timeDifference = endTime - startTime;
            System.out.println("***********************************************************");
            System.out.println("用时：【" + timeDifference + "】毫秒");
        }

运行结果,81ms
还有希尔排序、归并排序等等算法，一般我很少用到，有空再详细比较其他的算法。

总结

根据简单的一个代码测试，得出collection自带的方法效率最高，毕竟都写入源码的东西。