Java篇 - 进制与位运算应用实例

为什么要写这章呢？

阅读过JDK源代码的同学都知道，JDK里充斥着大量的位运算，位运算比一般的运算操作符在效率上快很多，而位运算与进制有着紧密的联系。使用位运算不仅能提高运算效率，还能实现一些奇yin巧技。

看看JDK里的一些位运算的代码：

// java.util.Arrays

public static void parallelSort(char[] a) {
        int n = a.length, p, g;
        if (n <= MIN_ARRAY_SORT_GRAN ||
            (p = ForkJoinPool.getCommonPoolParallelism()) == 1)
            DualPivotQuicksort.sort(a, 0, n - 1, null, 0, 0);
        else
            new ArraysParallelSortHelpers.FJChar.Sorter
                (null, a, new char[n], 0, n, 0,
                 ((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
                 MIN_ARRAY_SORT_GRAN : g).invoke();
    }

// java.math.BigInteger

private static int[] multiplyToLen(int[] x, int xlen, int[] y, int ylen, int[] z) {
        int xstart = xlen - 1;
        int ystart = ylen - 1;

        if (z == null || z.length < (xlen+ ylen))
            z = new int[xlen+ylen];

        long carry = 0;
        for (int j=ystart, k=ystart+1+xstart; j >= 0; j--, k--) {
            long product = (y[j] & LONG_MASK) *
                           (x[xstart] & LONG_MASK) + carry;
            z[k] = (int)product;
            carry = product >>> 32;
        }
        z[xstart] = (int)carry;

        for (int i = xstart-1; i >= 0; i--) {
            carry = 0;
            for (int j=ystart, k=ystart+1+i; j >= 0; j--, k--) {
                long product = (y[j] & LONG_MASK) *
                               (x[i] & LONG_MASK) +
                               (z[k] & LONG_MASK) + carry;
                z[k] = (int)product;
                carry = product >>> 32;
            }
            z[i] = (int)carry;
        }
        return z;
    }

// java.util.Collections的二分查找

private static 
    int indexedBinarySearch(List> list, T key) {
        int low = 0;
        int high = list.size()-1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            Comparable midVal = list.get(mid);
            int cmp = midVal.compareTo(key);

            if (cmp < 0)
                low = mid + 1;
            else if (cmp > 0)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found
    }

进入主题，我们先来看看进制的概念以及进制的分类，转换。

 

1. 进制。

计算机中我们经常使用的进制主要有：二进制、八进制、十进制、十六进制。

二进制，逢二进一，用两个阿拉伯数字：0、1；  

八进制，逢八进一，用八个阿拉伯数字：0、1、2、3、4、5、6、7；

十进制，逢十进一，用十个阿拉伯数字：0到9；  

十六进制，逢十六进一，但我们只有0~9这十个数字，所以用A，B，C，D，E，F这五个字母来分别表示10，11，12，13，14，15，字母不区分大小写。

计算机使用二进制存储数据，为什么不使用八进制、十进制、十六进制？

1.易于物理实现：二进制采用两种物理状态，而十进制是10种，显然前者简单。

2.二进制仅有3种运算规则（可以记成或，且，非），十进制多达55种。

3.机器可靠性高：两种状态较分明。

4.通用性强：与真与假相对应。

5.二进制最简单，只有0和1，计算速度是最快的。

既然二进制优势这么明显，为什么还会存在八进制、十进制、十六进制？

简单来说，就是为了阅读方便。二进制数书写冗长、易错、难记，而十进制数与二进制数之间的转换过程复杂，所以一般用十六进制数或八进制数作为二进制数的缩写。

 

2. 原码 反码 补码。

数值在计算机中是以补码的方式存储的，在探求为何计算机要使用补码之前， 让我们先了解原码， 反码和补码的概念。对于一个数， 计算机要使用一定的编码方式进行存储。 原码， 反码， 补码是计算机存储一个具体数字的编码方式。

一个数在计算机中的二进制表示形式，叫做这个数的机器数。机器数是带符号的，在计算机用一个数的最高位存放符号，正数为0， 负数为1。比如，十进制中的数+2 ，计算机字长为8位，转换成二进制就是[00000010]。如果是 -2 ，就是 [10000010] 。因为第一位是符号位，所以机器数的形式值就不等于真正的数值。例如上面的有符号数 [10000010]，其最高位1代表负，其真正数值是 -2 而不是形式值130（[10000010]转换成十进制等于130）。所以将带符号位的机器数对应的真正数值称为机器数的真值。

原码就是符号位加上真值的绝对值， 即用第一位表示符号， 其余位表示值。
反码的表示方法是: 正数的反码是其本身；负数的反码是在其原码的基础上，符号位不变，其余各个位取反。
补码的表示方法是: 正数的补码就是其本身；负数的补码是在其原码的基础上，符号位不变，其余各位取反，最后+1。 (即在反码的基础上+1)。

举例：

那么计算机为什么要使用补码呢？

首先，根据运算法则减去一个正数等于加上一个负数， 即: 1-1 = 1+(-1)， 所以计算机被设计成只有加法而没有减法，而让计算机辨别”符号位”会让计算机的基础电路设计变得十分复杂，于是就让符号位也参与运算，从而产生了反码。 

用反码计算，出现了”0”这个特殊的数值，0带符号是没有任何意义的。而且会有[0000 0000]和[1000 0000]两个编码表示0。于是设计了补码，负数的补码就是反码+1，正数的补码就是正数本身，从而解决了0的符号以及两个编码的问题: 用[0000 0000]表示0，用[1000 0000]表示-128。 
注意-128实际上是使用以前的-0的补码来表示的，所以-128并没有原码和反码。使用补码，不仅仅修复了0的符号以及存在两个编码的问题， 而且还能够多表示一个最低数。这就是为什么8位二进制，使用补码表示的范围为[-128， 127]。

 

3. 进制转换。

JDK给我们提供了很多显示的进制转换函数：

int n1 = 14;

// 十进制转成十六进制
Integer.toHexString(n1);

// 十进制转成八进制
Integer.toOctalString(n1);

// 十进制转成二进制
Integer.toBinaryString(12);

// 十六进制转成十进制
Integer.valueOf("FFFF",16).toString();

// 十六进制转成二进制
Integer.toBinaryString(Integer.valueOf("FFFF",16));

// 十六进制转成八进制
Integer.toOctalString(Integer.valueOf("FFFF",16));

// 八进制转成十进制
Integer.valueOf("576",8).toString();

// 八进制转成二进制
Integer.toBinaryString(Integer.valueOf("23",8));

// 八进制转成十六进制
Integer.toHexString(Integer.valueOf("23",8));

// 二进制转十进制
Integer.valueOf("0101",2).toString();

// 二进制转八进制
Integer.toOctalString(Integer.parseInt("0101", 2));

// 二进制转十六进制
Integer.toHexString(Integer.parseInt("0101", 2));

知其然必先知其所以然，我们来挨个分析下。

(1) 十进制转二进制

方法为：十进制数除2取余法，即十进制数除2，余数为权位上的数，得到的商值继续除2，依此步骤继续向下运算直到商为0为止。

如150：

150 % 2 = 75 余 0
75 % 2 = 37 余 1
37 % 2 = 18 余 1
18 % 2 = 9 余 0
9 % 2 = 4 余 1
4 % 2 = 2 余 0
2 % 2 = 1 余 0
1 % 2 = 0 余 1

除到商为0为止，然后逆序。
所以150的二进制为：10010110

 

(2) 二进制转十进制

方法为：把二进制数按权展开，相加即得十进制数。

如10010110：
总共8位。

1 * 2^7 + 0 * 2^6 + 0 * 2^5 + 1 * 2^4 + 0 * 2^3 + 1 * 2^2 + 1 * 2^1 + 0 * 2^0
= 128 + 0 + 0 + 16 + 0 + 4 + 2 + 0
= 150

 

(3) 二进制转八进制

方法为：3位二进制数按权展开，相加得到1位八进制数（注意：从右向左分，分割成3位时，不足补0）。

如：10010110
010 010 110  （凑9位，第一位补0）

0 * 2^2 + 1 * 2^1 + 0 * 2^0 = 2
0 * 2^2 + 1 * 2^1 + 0 * 2^0 = 2
1 * 2^2 + 1 * 2^1 + 0 * 2^0 = 6

八进制为：226

 

(4) 八进制转二进制

方法为：八进制数通过除2取余法，得到二进制数，对每个八进制为3个二进制，不足时在最左边补零。

如：226

2 ->  2 % 2 = 1 余 0
      1 % 2 = 0 余 1
      -------- 010

2 ->  2 % 2 = 1 余 0
      1 % 2 = 0 余 1
      -------- 010

6 ->  6 % 2 = 3 余 0
      3 % 2 = 1 余 1
      1 % 2 = 0 余 1
      -------- 110

10010110 （去掉第一个的0）

 

(5) 二进制转十六进制

方法为：与二进制转八进制方法近似，八进制是取三合一，十六进制是取四合一，不足时补0（从右向左分）。

如：100101100

0001 : 0 * 2^3 + 0 * 2^2 + 0 * 2^1 + 1 * 2^0 = 1
0010 : 0 * 2^3 + 0 * 2^2 + 1 * 2^1 + 0 * 2^0 = 2
1100 : 1 * 2^3 + 1 * 2^2 + 0 * 2^1 + 0 * 2^0 = 12

十六进制：0-9，a-f(A-F)，小a = 10, b = 11, c = 12
12超过了9，对应C

结果为：12C

 

(6) 十六进制转二进制

方法为：十六进制数通过除2取余法，得到二进制数，对每个十六进制为4个二进制，不足时在最左边补零。

如: 12C

1 : 1 % 2 = 0 余 1
    ------ 0001

2 : 2 % 2 = 1 余 0
    1 % 2 = 0 余 1
    ------ 0010

C(12): 12 % 2 = 6 余 0
       6 % 2 = 3 余 0
       3 % 2 = 1 余 1
       1 % 2 = 0 余 1
       ------- 1100

100101100

 

(7) 其他转换

十进制与八进制与十六进制之间的转换 ：

十进制转八进制或者十六进制有两种方法

第一：间接法—把十进制转成二进制，然后再由二进制转成八进制或者十六进制。

第二：把十进制转八进制或者十六进制按照除8或者16取余，直到商为0为止。

 

八进制或者十六进制转成十进制 ：

方法为：把八进制、十六进制数按权展开、相加即得十进制数。

 

十六进制与八进制之间的转换：

八进制与十六进制之间的转换有两种方法。

第一种：他们之间的转换可以先转成二进制然后再相互转换。

第二种：他们之间的转换可以先转成十进制然后再相互转换。

 

贴上测试代码：

public static void main(String[] args) {
        /**
         * 十进制转2进制，除以2，余1
         * 2进制转8进制，从右向左按3位分段，不够补0，然后与2获取结果。
         * 2进制转16进制，从右向左按4位分段，不够补0。
         */
        // ====== 十进制转二进制 =======
        int n = 298;
        /*
         * 298 % 2 = 149 ... 0
         * 149 % 2 = 74 ... 1
         * 74 % 2 = 37 ... 0
         * 37 % 2 = 18 ... 1
         * 18 % 2 = 9 ... 0
         * 9 % 2 = 4 ... 1
         * 4 % 2 = 2 ... 0
         * 2 % 2 = 1 ... 0
         * 1 % 2 = 0 ... 1
         *
         * 100101010
         */
        System.out.println(Integer.toBinaryString(n));

        // ====== 二进制转十进制 ======
        /*
         * 100110010
         *
         * 1*2^8 + 0*2^7 + 0*2^6 + 1*2^5 + 1*2^4 + 0*2^3 + 0*2^2 + 1*2^1 + 0*2^0
         * = 256 + 0 + 0 + 32 + 16 + 0 + 0 + 2 + 0
         * = 306
         */
        // Integer.valueOf最终是转成10进制输出
        System.out.println(Integer.valueOf("100110010", 2));

        // ====== 二进制转八进制 ======
        /*
         * 0110110
         *
         * 000 : 0*2^2 + 0*2^1 + 0*2^0 = 0
         * 110 : 1*2^2 + 1*2^1 + 0*2^0 = 6
         * 110 : 1*2^2 + 1*2^1 + 0*2^0 = 6
         *
         * 066，将第一个补的0去掉，最终为66
         */
        System.out.println(Integer.toOctalString(Integer.parseInt("0110110", 2)));

        // ====== 八进制转成二进制 ======
        /*
         * 53 （以0开头，0～7组成（小于8））
         *
         * 5 : 5 % 2 = 2 ... 1
         *     2 % 2 = 1 ... 0
         *     1 % 2 = 0 ... 1
         *     -------- 101
         *
         * 3 : 3 % 2 = 1 ... 1
         *     1 % 2 = 0 ... 1
         *     -------- 011
         *
         * 101011
         */
        System.out.println(Integer.toBinaryString(Integer.valueOf("53",8)));

        // ====== 二进制转十六进制 ======
        /*
         * 0111001
         *
         * 0011: 0*2^3 + 0*2^2 + 1*2^1 + 1*2^0 = 3
         * 1001: 1*2^3 + 0*2^2 + 0*2^1 + 1*2^0 = 9
         *
         * 39
         */
        System.out.println(Integer.toHexString(Integer.parseInt("0111001", 2)));

        // ====== 十六进制转二进制 ======
        /*
         * 783
         *
         * 7: 7 % 2 = 3...1
         *    3 % 2 = 1...1
         *    1 % 2 = 0...1
         *    ------ 0111
         *
         * 8: 8 % 2 = 4...0
         *    4 % 2 = 2...0
         *    2 % 2 = 1...0
         *    1 % 2 = 0...1
         *    ------ 1000
         *
         * 3: 3 % 2 = 1...1
         *    1 % 2 = 0...1
         *    ------ 0011
         *
         * 011110000011，去掉第一个补的0
         * 11110000011
         */
        System.out.println(Integer.toBinaryString(Integer.valueOf("783",16)));
    }

 

4. 进制应用实例

public final class _02_Hex_Practice {

    /**
     * Int转字节数组
     *
     * 1、(inta >> i * 8) & 0xff
     *
     * 移位 清零从左往右，按8位获取1字节。
     *
     * 2、这里使用的是小端法。地位字节放在内存低地址端，即该值的起始地址。
     * 补充：32位中分大端模式（PPC）和小段端模式（x86）。
     *
     * ------------------------------------------------------------------------------------------------------------------
     * 记得在学计算机原理的时候，了解到计算机内的存储都是利用二进制的补码进行存储的。
     *
     * 复习一下，原码反码补码这三个概念：
     *
     * 对于正数（00000001）原码来说，首位表示符号位，反码 补码都是本身
     * 对于负数（100000001）原码来说，反码是对原码除了符号位之外作取反运算即（111111110），补码是对反码作+1运算即（111111111）
     * ------------------------------------------------------------------------------------------------------------------
     * 补充：0xff
     *
     * 当将-127赋值给a[0]时候，a[0]作为一个byte类型，其计算机存储的补码是10000001（8位）。
     * 将a[0] 作为int类型向控制台输出的时候，jvm作了一个补位的处理，因为int类型是32位所以补位后的补码就是
     * 1111111111111111111111111 10000001（32位），这个32位二进制补码表示的也是-127.
     *
     * 发现没有，虽然byte->int计算机背后存储的二进制补码由10000001（8位）
     * 转化成了1111111111111111111111111 10000001（32位）很显然这两个补码表示的十进制数字依然是相同的。
     *
     * 但是我做byte->int的转化 所有时候都只是为了保持 十进制的一致性吗？
     * 不一定吧？好比我们拿到的文件流转成byte数组，难道我们关心的是byte数组的十进制的值是多少吗？我们关心的是其背后二进制存储的补码吧
     *
     * 所以大家应该能猜到为什么byte类型的数字要&0xff再赋值给int类型，其本质原因就是想保持二进制补码的一致性。
     *
     * 当byte要转化为int的时候，高的24位必然会补1，这样，其二进制补码其实已经不一致了，&0xff可以将高的24位置为0，低8位保持原样。
     * 这样做的目的就是为了保证二进制数据的一致性。
     *
     * 当然拉，保证了二进制数据性的同时，如果二进制被当作byte和int来解读，其10进制的值必然是不同的，因为符号位位置已经发生了变化。
     *
     * 象例2中，int c = a[0]&0xff;  a[0]&0xff=1111111111111111111111111 10000001&11111111=000000000000000000000000 10000001 ，
     * 这个值算一下就是129，
     *
     * 所以c的输出的值就是129。有人问为什么上面的式子中a[0]不是8位而是32位，因为当系统检测到byte可能会转化成int或者说byte与int类型进行运算的时候，
     * 就会将byte的内存空间高位补1（也就是按符号位补位）扩充到32位，再参与运算。上面的0xff其实是int类型的字面量值，所以可以说byte与int进行运算。
     * ------------------------------------------------------------------------------------------------------------------
     */
    private static byte[] int2Bytes(int inta) {
        // 32位Int可存于长度为4的字节数组
        byte[] bytes = new byte[4];
        for (int i = 0; i < bytes.length; i++) {
            // 移位和清零
            // >> 8 获取一个字节
            bytes[i] = (byte) (int) ((inta >> i * 8) & 0xff);
        }
        return bytes;
    }

    /**
     * 字节数组转Int
     */
    private static int bytes2Int(byte[] bytes) {
        int inta = 0;
        for (int i = 0; i < bytes.length; i++) {
            // 移位和清零
            inta += ((bytes[i] & 0xff) << i * 8);
        }
        return inta;
    }

    private static void test01() {
        // 将我的学号转换成字节码
        byte[] bytes = int2Bytes(1206010035);
        System.out.println(bytes[0] + " " + bytes[1] + " " + bytes[2] + " " + bytes[3]);
        // 字节码就可以转换回学号
        System.out.println(bytes2Int(bytes));
    }

    /**
     * long 转 byte数组
     */
    public static byte[] long2Bytes(long longa) {
        // 64位
        byte[] bytes = new byte[8];
        for (int i = 0; i < bytes.length; i++) {
            // 移位和清零
            // 移动8位获取一个字节，一个字节占8位
            bytes[i] = (byte) (long) (((longa) >> i * 8) & 0xff);
        }
        return bytes;
    }

    /**
     * byte数组 转 long
     */
    public static long bytes2Long(byte[] bytes) {
        long longa = 0;
        for (int i = 0; i < bytes.length; i++) {
            // 移位和清零
            longa += (long) ((bytes[i] & 0xff) << i * 8);
        }
        return longa;
    }

    public static void main(String[] args) {
        test01();
    }
}

 

5.  位运算使用

package io.kzw.advance._02_bit_hex;

/**
 * Java位运算使用.
 *
 * @author kzw on 2018/09/15.
 */
public final class _03_Bit {

    /*
     * ###### 前言
     *
     * 日常开发中位运算不是很常用，但是巧妙的使用位运算可以大量减少运行开销，优化算法。
     * 举个例子，翻转操作比较常见，比如初始值为1，操作一次变为0，再操作一次变为1。
     * 可能的做法是使用三木运算符，判断原始值为1还是0，如果是1，设置为0，否则设置为0.
     *
     * 但是使用位运算，不用判断原始值，直接改变值就可以：
     *
     * 1^num // num为原始值
     *
     * 当然，一条语句可能对代码没什么影响，但是在高重复，大数据量的情况下将会节省很多开销。
     *
     * 以下是自己整理的关于java位运算的部分内容，如有错误，还请指出，以共同进步，先行致谢。
     */
    private static void reverse() {
        int number = 1;
        for (int i = 0; i < 5; i++) {
            number = 1 ^ number;
            /*
             * 0
             * 1
             * 0
             * 1
             * 0
             */
            System.out.println(number);
        }
    }

    /*
     * ###### java支持的位运算符
     *
     * &：按位与。
     *
     * |：按位或。
     *
     * ~：按位非。
     *
     * ^：按位异或。
     *
     * <<：左位移运算符。
     *
     * >>：右位移运算符。
     *
     * <<<：无符号右移运算符。
     *
     * 位运算符中, 除～以外, 其余均为二元运算符。操作数只能为整型和字符型数据。
     *
     * Java使用 补码 来表示二进制数, 在补码表示中, 最高位为符号位, 正数的符号位为0, 负数为1。
     *
     * 补码的规定如下:
     *
     * 一、正整数的原码、反码、补码完全一样，即符号位固定为0，数值位相同
     * 二、负整数的符号位固定为1，由原码变为补码时，规则如下：
     *    1、原码符号位1不变，整数的每一位二进制数位求反，得到反码
     *    2、反码符号位1不变，反码数值位最低位加1，得到补码
     *
     *
     * 00000000000000000000000000000001  (-1)
     * 为何有那么多0、1，java中int是32位的。
     */

    /*
     * ###### 按位&
     *
     * 按位与的运算规则:
     * 0 0 1 1
     *    &
     * 0 1 0 1
     *    |
     *
     * 0 0 0 1
     *
     * 规则总结：只有两个操作数对应位同为1时，结果为1，其余全为0. （或者是只要有一个操作数为0，结果就为0）。
     */
    private static void test01() {
        /*
         * 10 & 12
         *
         * 10 % 2 = 5..0
         * 5 % 2 = 2..1
         * 2 % 2 = 1..0
         * 1 % 2 = 0..1
         * - 1010
         *
         * 同理：12 -> 1100
         * 也是补码哦
         * 1010 & 1100 = 1000
         * 转成10进制：1*2^3 + 0*2^2 + 0*2^1 + 0*2^0 = 8
         */
        System.out.println("10 & 12 = " + (10 & 12));

        /*
         * -6 & -2
         *
         * 以补码来存储，比如以8位的-6来表示，也可以是16位的，前面补1即可，凑足16位。
         *
         * -6:
         * 6 % 2 = 3..0
         * 3 % 2 = 1..1
         * 1 % 2 = 0..1
         * ---110
         *
         * 然后8位的来表示的话，前面补0，00000110
         * 取反，11111001, +1: 11111010，如果要表示成32位的，补1
         *
         * 得表示的二进制补码：11111111111111111111111111111010
         *
         * -2:
         * 2 % 2 = 1..0
         * 1 % 2 = 0..1
         * ---10
         * 00000010，取反: 11111101, +1: 11111110
         * 表示成32位：11111111111111111111111111111110
         *
         * 11111111111111111111111111111010
         *                &
         * 11111111111111111111111111111110
         *                =
         * 11111111111111111111111111111010
         *
         * 此时符号位为1，结果为补码，想求原码，需要-1取反
         * 11111111111111111111111111111001
         * 00000000000000000000000000000110
         * = 6
         * 加上符号位：-6，最终结果为-6
         *
         * 正数都是正常操作，负数就得先取补码，计算机都是补码操作，正数的补码和原码相同。
         * 补码&完成后，得到的是补码，其实正数也是一样，但是正数不需要还原。然后负数想得到原值，得 -1 取反。
         * 因为负数的补码为反码 + 1，负数的反码（除去符号位，其他位置取反）。最后得到的值，再加上符号位。
         */
        System.out.println("-6 & -2 = " + (-6 & -2));
    }

    /*
     * ###### 按位| （按位&，两个都为1则为1，按位|则是有一个为1则为1）
     *
     * 按位或的运算规则：
     * 0011
     *   |
     * 0101
     *   =
     * 0111
     *
     * 规则总结：只有两个操作数对应位同为0时，结果为0，其余全为1.（或者是只要有一个操作数为1，结果就为1）。
     */
    private static void test02() {
        /*
         * 6 | 12
         *
         * 1010 | 1100 = 1110 = 14
         */
        System.out.println("10 | 12 = " + (10 | 12));
    }

    /*
     * ###### 按位～（取反）
     *
     * 按位非的运算规则：
     * ~01 = 10
     */
    private static void test03() {
        System.out.println("~6 = " + (~6));
    }

    /*
     * ###### 按位^（异或），两个位都不相同时，则为1，相同时为0
     *
     * 按位异或的运算规则：两位不同时才为1，相同时为0
     * 0011
     *  ^
     * 0101
     *  =
     * 0110
     */
    private static void test04() {
        /*
         * 6 ^ 12
         *
         * 1010 ^ 1100 = 0110 = 6
         */
        System.out.println("10 ^ 12 = " + (10 ^ 12));
    }

    /*
     * ###### 左位移（<<，带符号）
     *
     * 规则：
     * 1）丢弃最高位，低位补0；
     * 2）如果移动位数超过了该类型的最大位数，那么编译器会对移动的位数取模操作；
     * 3）在没有溢出的情况下，对于正数和负数都相当于乘2操作；
     * 4）如果移近高级位（32/64）,那么该值将变为负数；
     */
    private static void test05() {
        /*
         * 2 << 2 = 8
         *
         * 00000010 << 2 = 00001000 = 1 * 2^3 = 8
         */
        System.out.println("2 << 2 = " + (2 << 2));
    }

    /*
     * ###### 右位移（>>，带符号）
     *
     * 规则：
     * 1）丢弃低位，高位补符号位；(负数补1，正数补0);
     * 2）对于正数和负数都相当于除2操作；
     */
    private static void test06() {
        /*
         * -6 >> 2 = -2
         *
         * -6：
         * 6 % 2 = 3..0
         * 3 % 2 = 1..1
         * 1 % 2 = 0..1
         *
         * 00000110，取反：11111001, +1 = 11111010
         *
         * -6的二进制补码为:11111010（在计算机里存储用的反码）
         *
         * 11111010>>2 = 11111110
         *
         * 注意：此时高位为1，为负数，需要取其原码才能得到它的值，如果高位为0，则不用。
         *
         * 负数求原码：-1再取反
         * -1: 11111101
         * ~: 00000010
         *
         * 得到原码：00000010 = 2
         *
         * 加上符号位: -2
         */
        System.out.println("-6 >> 2 = " + (-6 >> 2));
    }

    /*
     * ###### 无符号右移（>>>，无符号右移，只有右移才有无符号哦，丢弃高位，全部补0，0为正数，1为负数。）
     *
     * 低位移除，高位补0。
     * 注意，无符号右移（>>>）中的符号位（最高位）也跟着变，无符号的意思是将符号位当作数字位看待。
     * 如：-1>>>1结果为2147483647。这个数字应该比较熟悉，看两个输出语句就知道是什么了：
     *
     * System.out.println(Integer.toBinaryString(-1>>>1));
     * System.out.println(Integer.toBinaryString(Integer.MAX_VALUE));
     *
     * 输出结果为：
     * 1111111111111111111111111111111
     * 1111111111111111111111111111111
     *
     * -1>>>1竟然得到了int所能表示的最大整数，精彩。
     *
     * 除了使用-1>>>1能得到Integer.MAX_VALUE，以下的也能得到同样的结果：
     * //maxInt
     * System.out.println(~(1 << 31));
     * System.out.println((1 << -1)-1);
     * System.out.println(~(1 << -1));
     * 使用位运算往往能很巧妙的实现某些算法完成一些复杂的功能。
     */
    private static void test07() {
        /*
         * -6 >>> 2
         *
         * -6：
         * 6 % 2 = 3..0
         * 3 % 2 = 1..1
         * 1 % 2 = 0..1
         *
         * 00000000000000000000000000000110，取反：11111111111111111111111111111001, +1 = 11111111111111111111111111111010
         *
         * -6的二进制补码为:11111111111111111111111111111010（在计算机里存储用的反码）
         *
         * 11111111111111111111111111111010>>>2 = 00111111111111111111111111111110 = 1073741822
         *
         * 为什么上面 -6 >> 2位，与这边-6>>>2，一个用8位表示，一个用32位表示，其实int应该用32位表示，
         * 但是上面 -6 >> 2，补位完后高位为1，需要重新取反，而这边高位为1，结果无需取反。
         */
        System.out.println("-6 >>> 2 = " + (-6 >>> 2));
    }

    public static void main(String[] args) {
        /**
         * 总结：正数的反码，补码都是它本身。负数的补码为反码 + 1。
         * 计算机内部是以补码存储的。
         *
         * 高位为0为正数，高位为1为负数。
         *
         * 负数的各种位操作，得先获取负数的补码，就是取反+1，然后操作，最后得到的是补码，然后 - 1，取反，最后再加上符号就得到了结果。
         *
         * << , >>（带符号，正数高位补0，负数补1）, >>> （无符号右移，高位都补0），没有无符号<<<。
         *
         * &：都为1才为1，| ：一个为1则为1， ~:取反, ^ : 相同时为0，不同时才为1。
         */
//         reverse();
        // test01();
        // test02();
        // test03();
        // test04();
        // test05();
        // test06();
        // test07();
    }
}

 

 

6. 位运算应用实例

package io.kzw.advance._02_bit_hex;

/**
 * 位运算使用.
 *
 * @author kzw on 2018/09/15.
 */
public final class _04_Bit_Practice {

    /*
     * ###### [常见使用] 1. m * 2^n
     *
     * 可以使用m<> 32=" + (1 >> 32));
        // 1
        System.out.println("1 >> 0=" + (1 >> 0));
        // 0
        System.out.println("1 >> 31=" + (1 >> 31));
        // 0
        System.out.println("1 >> -1=" + (1 >> -1));
        // 0
        System.out.println("1 >> 30=" + (1 >> 30));
        // 0
        System.out.println("1 >> -2=" + (1 >> -2));
    }

    /*
     * ###### [常见使用] 2. 判断一个数的奇偶性
     *
     * n & 1 == 1 ? ”奇数” : ”偶数”
     *
     * 为什么与1能判断奇偶？所谓的二进制就是满2进1，那么好了，偶数的最低位肯定是0（恰好满2，对不对？），
     * 同理，奇数的最低位肯定是1.int类型的1，前31位都是0，无论是1&0还是0&0结果都是0，那么有区别的就是1的最低位上的1了，
     * 若n的二进制最低位是1（奇数）与上1，结果为1，反则结果为0.
     */
    private static void test02(int n) {
        System.out.println(n + "是 : " + ((n & 1) == 1 ? "奇数" : " 偶数"));
    }

    /*
     * ###### [常见使用] 3. 不用临时变量交换两个数
     *
     * 其实java中的异或运算法则完全遵守数学中的计算法则：
     * ①    a ^ a =0
     * ②    a ^ b =b ^ a
     * ③    a ^b ^ c = a ^ (b ^ c) = (a ^ b) ^ c;
     * ④    d = a ^b ^ c 可以推出 a = d ^ b ^ c.
     * ⑤    a ^ b ^a = b.
     */
    private static void test03() {
        int a = 3;
        int b = 4;
        a = a ^ b;
        b = b ^ a; // b = b ^ (a ^ b) --> b = a
        a = a ^ b; // (a ^ b) ^ (b ^ (a ^ b)) --> a = b
        // a = 4, b = 3
        System.out.println("a = " + a + " ,b = " + b);
    }

    /*
     * ###### [常见使用] 4. 取绝对值
     *
     * (a^(a>>31))-(a>>31)
     *
     * 先整理一下使用位运算取绝对值的思路：若a为正数，则不变，需要用异或0保持的特点；
     * 若a为负数，则其补码为源码翻转每一位后+1，先求其源码，补码-1后再翻转每一位，此时需要使用异或1具有翻转的特点。
     *
     * 任何正数右移31后只剩符号位0，最终结果为0，任何负数右移31后也只剩符号位1，溢出的31位截断，空出的31位补符号位1，
     * 最终结果为-1.右移31操作可以取得任何整数的符号位。
     *
     * 那么综合上面的步骤，可得到公式。a>>31取得a的符号，若a为正数，a>>31等于0，a^0=a，不变；若a为负数,a>>31等于-1 ，a^-1翻转每一位.
     */
    private static void test04(int n) {
        System.out.println(n + "的绝对值 = " + ((n ^ (n >> 31)) - (n >> 31)));
    }

    /*
     * ###### [常见使用] 5. 如何快速求取一个整数的7倍？
     *
     * (x<<3)-x
     */
    private static void test05(int n) {
        System.out.println(n + "的7倍 = " + ((n << 3) - n));
    }

    /*
     * ###### [常见使用] 6. 如何实现位操作求两个数的平均值?
     *
     * (x&y)+((x^y)>>1)
     */
    private static void test06(int x, int y) {
        System.out.println(x + "和" + y + "的平均值 = " + ((x & y) + ((x ^ y) >> 1)));
    }

    public static void main(String[] args) {
        // test01();
        // test02(3);
        // test02(10);
        // test03();
        // test04(-10);
        // test05(7);
        // test06(3,5);
    }
}

 

 

昨天加班，今天老况休息，但是陪了一天闺女，各种跑。上班累的是脑子，休息累的是身体，反正总得累一个。

这篇文章是我之前总结的，大部分用了源代码，算是偷个懒哈，今天晚上8点多才到家。

我的github链接：https://github.com/kuangzhongwen

代码都在里面。

明天的博客将会好好更，准备讲解下Java线程，线程的状态切换，以及线程池的原理。昨天临下班前还和同事讨论，为什么Java中的线程池，能够保证线程不死（按理线程执行完后就会死亡）。其实无外乎就是无限循环，在android framework源代码中ActivityThread，Looper, Zygote等都使用了无限循环。

 

先好好休息啦，准备明天新的一天～