一、参考

1、java高级之java的左移运算符和右移运算符

二、简述

1、定义：

2、速度：机器码是二进制01运算的，移位速度最快了

3、适用场景：

3.1、编码：字符编码，音频编码，压缩编码，加密编码
3.2、网络协议
3.3、数据文件格式：BMP,WAV
3.4、精确的bit操作

三、实例

既然是移位运算，那么int值肯定是要转成2进制数字才能看的直观明白。

Integer.toBinaryString(int num); //用来看到二进制的值。

以下就准备用15这个数字进行举例，不理解进制转换的请复习以下基础知识

1、正整数简单左移右移

2、int型移位运算右边参数是需要进行模32的运算(取余数)

这个听起来有点拗口对不对，既然是移位运算，那肯定是对对象带有的bit进行操作，那么先看看对象的存储bit位，另外每个数字类型，最高位其实是符号位，0正数，1负数。

// 和用二进制算的一样哦。Integer.MAX_VALUE = 2147483647  // 看了表就很容易理解模32的运算5<<1 = 5<<33 = 5<<(33%32) = 10

3、负数的移位运算

3.1、这个就略有复杂了，上面的例子中正数的位没有写全，其实
15 = 0000 0000 0000 0000 0000 0000 0000 1111
3.2、这里需要理解，原码，反码，补码。有点长，直接贴代码了，中间有...是中间的bit位，不影响计算。
3.3、计算：原负数值->原码->反码->补码->移位=移位后的原码->反码->补码->移位后的数值
3.4、代码举例

        //负数的移位运算
        //-15    = whyA = 1111 1111 1111 1111 1111 1111 1111 0001 
        //-15<<2 = whyB = 1111 1111 1111 1111 1111 1111 1100 0100 = -60
        //-15>>2 = whyC = 1111 1111 1111 1111 1111 1111 1111 1100 = -4
        //---------------------------------------------
        //我去，上面整懵了，why? 接下来的就有点复杂了
        //---------------------------------------------
        //whyA的获得
        //a、-15 原码 [1000 0000 ... 0000 1111]：最高位是符号位不动，其他和+15一样
        //b、-15 反码 [1111 1111 ... 1111 0000]
        //c、-15 补码 [1111 1111 ... 1111 0001] = whyA ：补码的话如果是1需要进位的，后面也有
        //---------------------------------------------
        //whyB的获得
        //d、-15 左移2位 原码 [1111 1111 ... 1100 0100]：以此为原码
        //e、-15 左移2位 反码 [1000 0000 ... 0011 1011]
        //f、-15 左移2位 补码 [1000 0000 ... 0011 1100] = -60 = whyB
        //---------------------------------------------
        //whyC的获得
        //d、-15 右移2位 原码 [1111 1111 ... 1111 1100]：以此为原码
        //e、-15 右移2位 反码 [1000 0000 ... 0000 0011]
        //f、-15 右移2位 补码 [1000 0000 ... 0000 0100] = -4 = whyC
        ComUtil.print("-15="+Integer.toBinaryString(-15)+                "\n-15<<2="+Integer.toBinaryString(-15<<2)+"="+(-15<<2)+                "\n-15>>2="+Integer.toBinaryString(-15>>2)+"="+(-15>>2)
                );

4、速度分析

本以为：移位运算 > 整型运算 > 浮点运算
实际：WTF，各位大大能解释一下，为啥java中整型比移位要快，是我用的不对么？

        //速度：（机器底层就是2进制1和0）移位>整型>浮点
        new Thread(new Runnable() {            public void run() {                //移位运算
                int a = 1;                long start = System.currentTimeMillis();                for(int i=0;i<Integer.MAX_VALUE;i++){
                    a = a<<5;
                }                long end = System.currentTimeMillis();
                ComUtil.print("移位运算耗时："+(end-start));//703
            }
        }).start();        
        new Thread(new Runnable() {            public void run() {                //整型计算
                int b = 1;                long start = System.currentTimeMillis();                for(int i=0;i<Integer.MAX_VALUE;i++){
                    b = b*32;
                }                long end = System.currentTimeMillis();
                ComUtil.print("整形运算耗时："+(end-start));//702
            }
        }).start();        
        new Thread(new Runnable() {            public void run() {                //浮点运算
                float c = 1f;                long start = System.currentTimeMillis();                for(int i=0;i<Integer.MAX_VALUE;i++){
                    c = c*32;
                }                long end = System.currentTimeMillis();
                ComUtil.print("浮点运算耗时："+(end-start));//3362
            }
        }).start();

至少，能看出移位和整型，比浮点快多了，对于复杂的循环计算有浮点的，可以按比例先换算成整型，最后再转成浮点型。

作者：Kandy_JS
链接：https://www.jianshu.com/p/415412d99c76