为何？为何？Java处理排序后的数组比没有排序的快？想过没有？

先看再点赞，给本身一点思考的时间，微信搜索【沉默王二】关注这个有颜值却伪装靠才华苟且的程序员。
本文 GitHub github.com/itwanger 已收录，里面还有我精心为你准备的一线大厂面试题。

今天周日，没什么重要的事情要作，因而我早早的就醒来了。看了一会渡边淳一的书，心里逐渐感到平静——心情不佳的时候，书好像是最好的药物。心情平静了，就须要作一些更有意义的事情——逛技术网站，学习精进。

Stack Overflow 是我最喜欢逛的一个网站，它是我 Chrome 浏览器的第一个书签。里面有不少不少经典的问题，其中一些回答，剖析得深刻我心。就好比说这个：“为何处理排序后的数组比没有排序的快？”

毫无疑问，直观印象里，排序后的数组处理起来就是要比没有排序的快，甚至不须要理由，就好像咱们知道“夏天吃冰激凌就是爽，冬天穿羽绒服就是暖和”同样。

但本着“知其然知其因此然”的态度，咱们确实须要去搞清楚究竟是为何？

来看一段 Java 代码：

/**
 * @author 沉默王二，一枚有趣的程序员
 */
public class SortArrayFasterDemo {
    public static void main(String[] args) {
        // 声明数组
        int arraySize = 32768;
        int data[] = new int[arraySize];

        Random rnd = new Random(0);
        for (int c = 0; c < arraySize; ++c) {
            data[c] = rnd.nextInt() % 256;
        }

        // !!! 排序后，比没有排序要快
        Arrays.sort(data);

        // 测试
        long start = System.nanoTime();
        long sum = 0;

        for (int i = 0; i < 100000; ++i)
        {
            // 循环
            for (int c = 0; c < arraySize; ++c)
            {
                if (data[c] >= 128) {
                    sum += data[c];
                }
            }
        }

        System.out.println((System.nanoTime() - start) / 1000000000.0);
        System.out.println("sum = " + sum);
    }
}

这段代码很是简单，我来解释一下：

• 声明一个指定长度（32768）的数组。

• 声明一个 Random 随机数对象，种子是 0；rnd.nextInt() % 256 将会产生一个余数，余数的绝对值在 0 到 256 之间，包括 0，不包括 256，多是负数；使用余数对数组进行填充。

• 使用 Arrays.sort() 进行排序。

• 经过 for 循环嵌套计算数组累加后的结果，并经过 System.nanoTime() 计算先后的时间差，精确到纳秒级。

我本机的环境是 Mac OS，内存 16 GB，CPU Intel Core i7，IDE 用的是 IntelliJ IDEA，排序后和未排序后的结果以下：

排序后：2.811633398
未排序：9.41434346

时间差仍是很明显的，对吧？未排序的时候，等待结果的时候让我有一种担忧：何时结束啊？不会结束不了吧？

读者朋友们有没有玩过火炬之光啊？一款很是经典的单机游戏，每个场景都有一副地图，地图上有不少分支，但只有一个分支能够通往下一关；在没有刷图以前，地图是模糊的，玩家并不知道哪一条分支是正确的。

若是侥幸跑的是一条正确的分支，那么很快就能到达下一关；不然就要往回跑，寻找正确的那条分支，须要花费更多的时间，但同时也会收获更多的经验和声望。

做为一名玩过火炬之光好久的老玩家，几乎每一幅地图我都刷过不少次，刷的次数多了，地图差很少就刻进了个人脑壳，即使是一开始地图是模糊的，我也能凭借经验和直觉找到最正确的那条分支，就省了不少折返跑的时间。

读者朋友们应该注意到了，上面的代码中有一个 if 分支——if (data[c] >= 128)，也就是说，若是数组中的值大于等于 128，则对其进行累加，不然跳过。

那这个代码中的分支就好像火炬之光中的地图分支，若是处理器可以像我同样提早预判，那累加的操做就会快不少，对吧？

处理器的内部结构我是不懂的，但它应该和个人大脑是相似的，遇到 if 分支的时候也须要停下来，猜一猜，到底要不要继续，若是每次都猜对，那显然就不须要折返跑，浪费时间。

这就是传说中的分支预测！

我须要刷不少次图才能正确地预测地图上的路线，处理器须要排序才能提升判断的准确率。

计算机发展了这么多年，已经变得很是很是聪明，对于条件的预测一般能达到 90% 以上的命中率。可是，若是分支是不可预测的，那处理器也无能为力啊，对不对？

排序后花费的时间少，未排序花费的时间多，罪魁祸首就在 if 语句上。

if (data[c] >= 128) {
    sum += data[c];
}

数组中的值是均匀分布的（-255 到 255 之间），至因而怎么均匀分布的，咱们暂且无论，反正由 Random 类负责。

为了方便讲解，咱们暂时忽略掉负数的那一部分，从 0 到 255 提及。

来看通过排序后的数据：

data[] = 0, 1, 2, 3, 4, ... 126, 127, 128, 129, 130, ... 250, 251, 252, ...
branch = N  N  N  N  N  ...   N    N    T    T    T  ...   T    T    T  ...

       = NNNNNNNNNNNN ... NNNNNNNTTTTTTTTT ... TTTTTTTTTT

N 是小于 128 的，将会被 if 条件过滤掉；T 是将要累加到 sum 中的值。

再来看未排序的数据：

data[] = 226, 185, 125, 158, 198, 144, 217, 79, 202, 118,  14, 150, 177, 182, 133, ...
branch =   T,   T,   N,   T,   T,   T,   T,  N,   T,   N,   N,   T,   T,   T,   N  ...

       = TTNTTTTNTNNTTTN ...   

彻底没有办法预测。

对比事后，就能发现，排序后的数据在遇到分支预测的时候，可以轻松地过滤掉 50% 的数据，对吧？是有规律可循的。

那假如说不想排序，又想节省时间，有没有办法呢？

若是你直接问个人话，我确定毫无办法，两手一摊，一副无奈脸。不过，Stack Overflow 以上帝视角给出了答案。

把：

if (data[c] >= 128) {
    sum += data[c];
}

更换为：

int t = (data[c] - 128) >> 31;
sum += ~t & data[c];

经过位运算消除了 if 分支（并不彻底等同），但我测试了一下，计算后的 sum 结果是相同的。

/**
 * @author 沉默王二，一枚有趣的程序员
 */
public class SortArrayFasterDemo {
    public static void main(String[] args) {
        // 声明数组
        int arraySize = 32768;
        int data[] = new int[arraySize];

        Random rnd = new Random();
        for (int c = 0; c < arraySize; ++c) {
            data[c] = rnd.nextInt() % 256;
        }

        // 测试
        long start = System.nanoTime();
        long sum = 0;

        for (int i = 0; i < 100000; ++i)
        {
            // 循环
            for (int c = 0; c < arraySize; ++c)
            {
                if (data[c] >= 128) {
                    sum += data[c];
                }
            }
        }

        System.out.println((System.nanoTime() - start) / 1000000000.0);
        System.out.println("sum = " + sum);

        // 测试
        long start1 = System.nanoTime();
        long sum1 = 0;

        for (int i = 0; i < 100000; ++i)
        {
            // 循环
            for (int c = 0; c < arraySize; ++c)
            {
                int t = (data[c] - 128) >> 31;
                sum1 += ~t & data[c];
            }
        }

        System.out.println((System.nanoTime() - start1) / 1000000000.0);
        System.out.println("sum1 = " + sum1);
    }
}

输出结果以下所示：

8.734795196
sum = 156871800000
1.596423307
sum1 = 156871800000

数组累加后的结果是相同的，但时间上仍然差得很是多，这说明时间确实耗在分支预测上——若是数组没有排序的话。

最后，不得不说一句，大神级程序员不愧是大神级程序员，懂得位运算的程序员就是屌。

建议还在读大学的读者朋友多读一读《计算机操做系统原理》这种涉及到底层的书，对成为一名优秀的程序员颇有帮助。毕竟大学期间，学习时间充分，社会压力小，可以作到心无旁骛，加油！

---

我是沉默王二，一枚有颜值却伪装靠才华苟且的程序员。关注便可提高学习效率，别忘了三连啊，点赞、收藏、留言，我不挑，奥利给🌹。

注：若是文章有任何问题，欢迎绝不留情地指正。

若是你以为文章对你有些帮助，欢迎微信搜索「沉默王二」第一时间阅读，回复关键字「小白」能够免费获取我肝了 4 万+字的 《Java 小白从入门到放肆》2.0 版；本文 GitHub github.com/itwanger 已收录，欢迎 star。