JDK源码之Integer类—reverse()方法

最新推荐文章于 2021-10-11 23:56:49 发布
最新推荐文章于 2021-10-11 23:56:49 发布
阅读量907 收藏
点赞数 1
分类专栏： # JDK源码 文章标签： Java JDK源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/cnds123321/article/details/117388322
版权

reverse()方法的功能是将一个int类型数值的所有二进制位反转，然后返回反转后的int数值。

例如数字987654321的二进制是0011 1010 1101 1110 0110 1000 1011 0001，反转二进制位后是1000 1101 0001 0110 0111 1011 0101 1100。

简单的来说所谓的反转就是：如字符串"ABCD"，反转后的字符串是"DCBA"，而该方法就是反转二进制位。

该方法的源代码如下：

    /**
     * 返回通过反转指定int值的二进制补码二进制表示中的位顺序而获得的值。
     * 例如数字987654321的二进制是0011 1010 1101 1110 0110 1000 1011 0001
     * 反转二进制位后是1000 1101 0001 0110 0111 1011 0101 1100
     *
     * @param i 要进行反转的int值
     * @return 返回反转二进制位后的数值
     */
    public static int reverse(int i) {
        i = (i & 0x55555555) << 1 | (i >>> 1) & 0x55555555;
        i = (i & 0x33333333) << 2 | (i >>> 2) & 0x33333333;
        i = (i & 0x0f0f0f0f) << 4 | (i >>> 4) & 0x0f0f0f0f;
        i = (i << 24) | ((i & 0xff00) << 8) |
                ((i >>> 8) & 0xff00) | (i >>> 24);
        return i;
    }

该算法的思路是：将32位二进制每两位分组，然后交换每组中相邻的单1位；再每四位分组，交换每组中相邻的2位；再每八位分组，交换每组中相邻的4位；再每十六位、三十二位进行同样的操作。

用字符串来演示该思路，如下：

字符串："ABCDEFGHIJKLMNOP"，反转后的字符串是："PONMLKJIHGFEDCBA"
两两分组交换相邻1位的字符
AB CD EF GH IJ KL MN OP
BA DC FE HG JI LK NM PO
四四分组交换相邻2位的字符
BADC FEHG JILK NMPO
DCBA HGFE LKJI PONM
八八分组交换相邻4位的字符
DCBAHGFE LKJIPONM
HGFEDCBA PONMLKJI
十六十六分组交换相邻8位的字符
HGFEDCBAPONMLKJI
PONMLKJIHGFEDCBA
完成反转

用二进制来演示该思路：

例如对十进制数字12345678进行反转
    第一步，两两分组12 34 56 78，交换每组中相邻的单1位21 43 65 87
    第二步，四四分组2143 6587，交换每组中相邻的2位4321 8765
    第三步，八八分组43218765，交换每组中相邻的4位87654321，完成反转
例如数字987654321的二进制0011 1010 1101 1110 0110 1000 1011 0001
    第一步，两两分组        00 11 10 10 11 01 11 10 01 10 10 00 10 11 00 01
        交换每组中相邻的1位 00 11 01 01 11 10 11 01 10 01 01 00 01 11 00 10
    第二步，四四分组        0011 0101 1110 1101 1001 0100 0111 0010
        交换每组中相邻的2位 1100 0101 1011 0111 0110 0001 1101 1000
    第三步，八八分组        11000101 10110111 01100001 11011000
        交换每组中相邻的4位 01011100 01111011 00010110 10001101
    第四步，十六十六分组     0101110001111011 0001011010001101
        交换每组中相邻的8位  0111101101011100 1000110100010110
    第五步，三十二三十二分组  01111011010111001000110100010110
        交换每组中相邻的16位 10001101000101100111101101011100

交换的过程如下：

该方法代码的执行过程如下：

/*
        i = (i & 0x55555555) << 1 | (i >>> 1) & 0x55555555;
        i = (i & 0x33333333) << 2 | (i >>> 2) & 0x33333333;
        i = (i & 0x0f0f0f0f) << 4 | (i >>> 4) & 0x0f0f0f0f;
        i = (i << 24) | ((i & 0xff00) << 8) | ((i >>> 8) & 0xff00) | (i >>> 24);

        0x55555555=0101 0101 0101 0101 0101 0101 0101 0101
        0xAAAAAAAA=1010 1010 1010 1010 1010 1010 1010 1010
        0x33333333=0011 0011 0011 0011 0011 0011 0011 0011
        0xCCCCCCCC=1100 1100 1100 1100 1100 1100 1100 1100
        0x0f0f0f0f=0000 1111 0000 1111 0000 1111 0000 1111
        0xf0f0f0f0=1111 0000 1111 0000 1111 0000 1111 0000
        0xff00    =0000 0000 0000 0000 1111 1111 0000 0000

        以数字987654321的二进制是0011 1010 1101 1110 0110 1000 1011 0001为例
        ①x = (i & 0x55555555) <<  1 | (i & 0xAAAAAAAA) >>>  1;等价于i = (i & 0x55555555) << 1 | (i >>> 1) & 0x55555555
            (i & 0x55555555)
                00 11 10 10 11 01 11 10 01 10 10 00 10 11 00 01
               &
                01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01
               =00 01 00 00 01 01 01 00 01 00 00 00 00 01 00 01     两两分组，然后保留每组中的低1位
            (i & 0x55555555) << 1
                00 10 00 00 10 10 10 00 10 00 00 00 00 10 00 10     左移1位，为两两分组中每组的相邻1位的交换做准备
            (i & 0xAAAAAAAA)
                00 11 10 10 11 01 11 10 01 10 10 00 10 11 00 01
               &
                10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10
               =00 10 10 10 10 00 10 10 00 10 10 00 10 10 00 00     两两分组，然后保留每组中的高1位
            (i & 0xAAAAAAAA) >>>  1
                00 01 01 01 01 00 01 01 00 01 01 00 01 01 00 00     无符号右移1位，为两两分组中每组的相邻1位的交换做准备
            (i & 0x55555555) <<  1 | (i & 0xAAAAAAAA) >>>  1
                00 10 00 00 10 10 10 00 10 00 00 00 00 10 00 10
               |
                00 01 01 01 01 00 01 01 00 01 01 00 01 01 00 00
               =00 11 01 01 11 10 11 01 10 01 01 00 01 11 00 10     交换两两分组中每组中相邻的1位
       ②i = (i & 0x33333333) << 2 | (i & 0xCCCCCCCC)>>>2;等价于i = (i & 0x33333333) << 2 | (i >>> 2) & 0x33333333;
            (i & 0x33333333)
                0011 0101 1110 1101 1001 0100 0111 0010
               &
                0011 0011 0011 0011 0011 0011 0011 0011
               =0011 0001 0010 0001 0001 0000 0011 0010             四四分组，然后保留每组中的低2位
           (i & 0x33333333) << 2
                1100 0100 1000 0100 0100 0000 1100 1000             左移2位，为四四分组中每组的相邻2位的交换做准备
           (i & 0xCCCCCCCC)
                0011 0101 1110 1101 1001 0100 0111 0010
               &
                1100 1100 1100 1100 1100 1100 1100 1100
               =0000 0100 1100 1100 1000 0100 0100 0000             四四分组，然后保留每组中的高2位
           (i & 0xCCCCCCCC)>>>2
                0000 0001 0011 0011 0010 0001 0001 0000             无符号右移2位，为四四分组中每组的相邻2位的交换做准备
           (i & 0x33333333) << 2 | (i & 0xCCCCCCCC)>>>2
                1100 0100 1000 0100 0100 0000 1100 1000
               |
                0000 0001 0011 0011 0010 0001 0001 0000
               =1100 0101 1011 0111 0110 0001 1101 1000             交换四四分组中每组中相邻的2位
        ③i = (i & 0x0f0f0f0f) << 4 | (i & 0xf0f0f0f0) >>> 4;等价于i = (i & 0x0f0f0f0f) << 4 | (i >>> 4) & 0x0f0f0f0f;
            (i & 0x0f0f0f0f)
               11000101 10110111 01100001 11011000
              &
               00001111 00001111 00001111 00001111
              =00000101 00000111 00000001 00001000                  八八分组，然后保留每组中的低4位
            (i & 0x0f0f0f0f) << 4
               01010000 01110000 00010000 10000000                  左移4位，为八八分组中每组的相邻4位的交换做准备
            (i & 0xf0f0f0f0)
               11000101 10110111 01100001 11011000
              &
               11110000 11110000 11110000 11110000
              =11000000 10110000 01100000 11010000                  八八分组，然后保留每组中的高4位
           (i & 0xf0f0f0f0) >>> 4
               00001100 00001011 00000110 00001101                  无符号右移4位，为八八分组中每组的相邻4位的交换做准备
          (i & 0x0f0f0f0f) << 4 | (i & 0xf0f0f0f0) >>> 4
               01010000 01110000 00010000 10000000
              |
               00001100 00001011 00000110 00001101
              =01011100 01111011 00010110 10001101                  交换八八分组中每组中相邻的4位
       ④(i << 24) | ((i & 0xff00) << 8) | ((i >>> 8) & 0xff00) | (i >>> 24)
              (i << 24)
                  10001101 00000000 00000000 00000000               保留三十二位中的从左往右数第四个八位二进制10001101，保留在从左往右数第一个八位的位置
              ((i & 0xff00) << 8)
              (i & 0xff00)
                  01011100 01111011 00010110 10001101
                 &
                  00000000 00000000 11111111 00000000
                 =00000000 00000000 00010110 00000000
              (i & 0xff00) << 8
                  00000000 00010110 00000000 00000000               保留三十二位中的从左往右数第三个八位二进制00010110，保留在从左往右数第二个八位的位置
              ((i >>> 8) & 0xff00)
              (i >>> 8)
                 00000000 01011100 01111011 00010110
              ((i >>> 8) & 0xff00)
                 00000000 01011100 01111011 00010110
                &
                 00000000 00000000 11111111 00000000
                =00000000 00000000 01111011 00000000                保留三十二位中的从左往右数第二个八位二进制01111011，保留在从左往右数第三个八位的位置
              (i >>> 24)
                 00000000 00000000 00000000 01011100                保留三十二位中的从左往右数第一个八位二进制01011100，保留在从左往右数第四个八位的位置
              (i << 24) | ((i & 0xff00) << 8) | ((i >>> 8) & 0xff00) | (i >>> 24)
                 10001101 00000000 00000000 00000000
                |
                 00000000 00010110 00000000 00000000
                |
                 00000000 00000000 01111011 00000000
                |
                 00000000 00000000 00000000 01011100
                =10001101 00010110 01111011 01011100                将已经交换位置的八位二进制整合到一起
 */

x = (i & 0x55555555) <<  1 | (i & 0xAAAAAAAA) >>>  1;等价于i = (i & 0x55555555) << 1 | (i >>> 1) & 0x55555555这样的代码中，其中i = (i & 0x55555555) << 1 | (i >>> 1) & 0x55555555是对前者代码的优化，源码中的就是优化代码，但是我们看未优化的代码才能更加方便地理解这个算法的原理。

第①、②、③步都是一样的原理，第④其实也是，但它的代码和reverseByte()方法的源码一致，可以看看该方法来加深理解。

第③步移位过程图解（i = (i & 0x0f0f0f0f) << 4 | (i & 0xf0f0f0f0) >>> 4;）

关于优化代码和未优化代码的模拟比较：

  • 未优化代码【i = (i & 0x0f0f0f0f) << 4 | (i & 0xf0f0f0f0) >>> 4;】：先保留每组的低4位，剔除掉每组高4位的数据（即将高4位全部置为0），然后将低4位移到高4位位置；再保留每组的高4位，剔除掉每组低4位的数据（即将低4位全部置为0），然后将高4位移到低4位位置；最后用或运算整合每组的低4位和高4位。
  • 优化代码【i = (i & 0x0f0f0f0f) << 4 | (i >>> 4) & 0x0f0f0f0f;】：先保留每组的低4位，剔除掉每组高4位的数据（即将高4位全部置为0），然后将低4位移到高4位位置；再将每组的高4位移动到低4位的位置（即用每组的高4位替换掉低4位），再剔除掉高4位的数据（即将高4位全部置为0）；最后用或运算整合每组的低4位和高4位。
        ③i = (i & 0x0f0f0f0f) << 4 | (i & 0xf0f0f0f0) >>> 4;等价于i = (i & 0x0f0f0f0f) << 4 | (i >>> 4) & 0x0f0f0f0f;
            (i & 0x0f0f0f0f)
               11000101 10110111 01100001 11011000
              &
               00001111 00001111 00001111 00001111
              =00000101 00000111 00000001 00001000                  八八分组，然后保留每组中的低4位
            (i & 0x0f0f0f0f) << 4
               01010000 01110000 00010000 10000000                  左移4位，为八八分组中每组的相邻4位的交换做准备
            (i & 0xf0f0f0f0)
               11000101 10110111 01100001 11011000
              &
               11110000 11110000 11110000 11110000
              =11000000 10110000 01100000 11010000                  八八分组，然后保留每组中的高4位
           (i & 0xf0f0f0f0) >>> 4
               00001100 00001011 00000110 00001101                  无符号右移4位，为八八分组中每组的相邻4位的交换做准备
          (i & 0x0f0f0f0f) << 4 | (i & 0xf0f0f0f0) >>> 4
               01010000 01110000 00010000 10000000
              |
               00001100 00001011 00000110 00001101
              =01011100 01111011 00010110 10001101                  交换八八分组中每组中相邻的4位
        ③i = (i & 0x0f0f0f0f) << 4 | (i >>> 4) & 0x0f0f0f0f;
            (i & 0x0f0f0f0f)
               11000101 10110111 01100001 11011000
              &
               00001111 00001111 00001111 00001111
              =00000101 00000111 00000001 00001000                  八八分组，然后保留每组中的低4位
            (i & 0x0f0f0f0f) << 4
               01010000 01110000 00010000 10000000                  左移4位，为八八分组中每组的相邻4位的交换做准备
            (i >>> 4)
               00001100 01011011 01110110 00011101                  将每组的高4位移动到每组的低4位中，覆盖掉原来的低4位，也相当于保留了高4位
            (i >>> 4) & 0x0f0f0f0f
               00001100 01011011 01110110 00011101
              &
               00001111 00001111 00001111 00001111
              =00001100 00001011 00000110 00001101                  剔除掉高4位中不必要数据，我们只需要每组的低4位参与运算
            (i & 0x0f0f0f0f) << 4 | (i >>> 4) & 0x0f0f0f0f
               01010000 01110000 00010000 10000000
              |
               00001100 00001011 00000110 00001101
              =01011100 01111011 00010110 10001101

参考链接：Integer相关方法的源码解析

从JDK源码角度看Integer
seaboat——a free boat on the sea.（公众号：远洋号）
08-15 1万+
概况Java的Integer类主要的作用就是对基本类型int进行封装，提供了一些处理int类型的方法，比如int到String类型的转换方法或String类型到int类型的转换方法，当然也包含与其他类型之间的转换方法。除此之外还有一些位相关的操作。继承结构--java.lang.Object --java.lang.Number --java.lang.Integer主要属性第一部分pu
从JDK源码看StringBuilder
seaboat——a free boat on the sea.（公众号：远洋号）
05-25 1696
概况 在 Java 中处理字符串时经常会使用 String 类，实际上 String 对象的值是一个常量，一旦创建后不能被改变。正是因为其不可变，所以也无法进行修改操作，只有不断地 new 出新的 String 对象。 为此 Java 引入了可变字符串变量 StringBuilder 类，它不是线程安全的，只用在单线程场景下。 继承结构 --java.lang.Object -...
详解Java中的Integer.reverse()方法，一步一步带你分析
taotao的博客
09-07 2559
详解Java中的Integer.reverse()方法，一步一步带你分析 假设有一个十进制整数，要将它的32位二进制按位反转后再以十进制数输出，要怎么做呢？ 比如说： 43261597(32位二进制：00000010100101000001111010011101) 反转后：-1183307456(32位二进制：10111001011110000010100101000000) （Java中使用补码来表示整数，其32位二进制的第一位表示符号，0为正，1为负） 可能我们第一反应就是通过Integer.t
reverse-integer
m0_37924505的博客
05-03 263
题目描述 Reverse digits of an integer. Example1: x = 123, return 321 Example2: x = -123, return -321 click to show spoilers. Have you thought about this? Here are some good questions to ask before codi...
Reverse Integer（整数反转）
Mr_Curious的博客
01-01 3657
Given a 32-bit signed integer, reverse digits of an integer. Example 1: Input: 123 Output: 321 Example 2: Input: -123 Output: -321 Example 3: Input: 120 Output: 21 Note:
7. Reverse Integer（颠倒整数）
只愿不违本心的博客
03-26 360
给定一个范围为 32 位 int 的整数，将其颠倒。 例 1: 输入: 123 输出: 321 例 2: 输入: -123 输出: -321 例 3: 输入: 120 输出: 21 注意: 假设我们的环境只能处理 32 位 int 范围内的整数。根据这个假设，如果颠倒后的结果超过这个范围，则返回 0。 public class Solution { publi...
java integer类,Java Integer类reverse()方法与示例
weixin_34199161的博客
03-13 495
整数类reverse()方法reverse()方法在java.lang包中可用。reverse()方法用于返回通过反转给定参数的二进制2的补码表示形式的位顺序生成的值。reverse()方法是一个静态方法，也可以使用类名进行访问，如果我们尝试使用类对象访问该方法，则也不会收到错误。reverse()方法在反转位顺序时不会引发异常。语法：publicstaticintreverse(intv...
JDK1.8:JDK1.8源码解析-源码解析
03-24
JDK1.8引入了Lambda表达式，这是一种简洁的函数式编程特性，可以用于代替具有单个抽象方法的接口的匿名内部类。Lambda表达式的语法如下： ```java (data -> expression) ``` 其中`data`是参数，`expression`是基于...
JDK源码解析---Integer
gongsenlin341的博客
07-31 726
文章目录1.概述2.类图3.属性4.构造方法5.缓存6.toXXXString7. 求Integer数值的长度8.parseXXX9.valueOf10.XXXValue 转换成其他类型的数值返回11.hashCode12.其他方法 1.概述 Integer是int的包装类，最大值为231-1，最小值为-231。Integer类主要的作用就是对基本类型int进行封装，提供了一些处理int类型的方法。 2.类图 和其他包装类一样， 继承了Number，实现了数值类型转换的方法 实现了Comparabel接口
Integer类中reverse方法探究
u013190513的博客
04-24 3354
java源代码Integer类中提供了reverse(int i)方法，这个方法的作用是用来将int类型变量的二进制表示进行按位反转。数值类型变量进行按位反转的问题和常见的数字反转以及字符串反转和数组反转其实都是同一类型的问题，所以对于这个问题的讨论也有利于我们在遇到这种类型的其他问题时可以举一反三，开拓思维。对于int变量的按位反转有几种方式，http://blog.youkuaiyun.com/ammana
java integer reverse_整数反转（ReverseInteger）
weixin_35643153的博客
02-24 844
题目描述给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。栗子1:输入: 123输出: 321栗子 2:输入: -123输出: -321栗子 3:输入: 120输出: 21注意：假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [$-2^{31}$, $2^{31}-1$]。请根据这个假设，如果反转后整数溢出那么就返回 0。来源：力扣(LeetCode)著作...
Reverse-Interger
点滴初学者的博客
09-03 223
Reverse digits of an integer. Example1: x = 123, return 321 Example2: x = -123, return -321 click to show spoilers. Have you thought about this? Here are some good questions to ask befo
java integer reverse_Java Integer reverse()方法
weixin_30430333的博客
02-12 298
Java Integer reverse()方法java.lang.Integer.reverse()方法返回通过比特的反转顺序，指定int值的二进制补码表示法得到的值。1 语法public static int reverse(int i)2 参数i ：这是int值。3 返回值此方法返回通过位的反转顺序,指定的int值而得到的值。4 示例package com.yiidian;/*** 一点...
java reverse_Java Integer类reverse（）方法与示例
cumt951045的博客
07-11 3787
java reverse 整数类reverse()方法 (Integer class reverse() method) reverse() method is available in java.lang package. reverse()方法在java.lang包中可用。 reverse() method is used to returns the value generated by...
JAVA中Integer源码的reverse方法全面细致解析
CodeYello的博客
10-11 534
在写leetcode网站的“”190. 颠倒二进制位”算法题时发现了这个方法的源码，于是有了如下研究成果。 大致思想原理 若要翻转一个二进制串，可以将其均分成左右两部分，再对划分出的左右部分各自进行划分左右，直至每部分只有一个元素 （对每部分递归执行翻转操作） 然后将左半部分拼在右半部分的后面，即完成了翻转 （例如12，左半放右半后面变为21就是翻转；1234，先划分左右，到各区域仅1个元素后开始返回，第一次返回2143，第二次返回4321，翻转完成） 由于左右两部分的计算方式是相似的，利用位掩码和位移运算
Reverse Integer -- LeetCode
编程语言小筑
02-27 260
原题链接:http://oj.leetcode.com/problems/reverse-integer/这道题思路非常简单，就是按照数字位反转过来就可以，基本数字操作。但是这种题的考察重点并不在于问题本身，越是简单的题目越要注意细节，一般来说整数的处理问题要注意的有两点，一点是符号，另一点是整数越界问题。代码如下： public int reverse(int x) { if(x=...
Reverse Integer
尘埃的博客
08-10 748
class Solution { public: int reverse(int x) { int sum = 0; while( x ) { sum = sum * 10 + x % 10; x /= 10; } return sum; } };
Reverse-integer
Howie66的博客
06-19 207
题目描述Reverse digits of an integer.Example1: x = 123, return 321Example2: x = -123, return -321click to show spoilers.Have you thought about this?Here are some good questions to ask before coding. Bonus...
07-Reverse Integer(整数反转)
ShadowAJ
05-10 254
题目： 给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 注意: 假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。 请根据这个假设，如果反转后整数溢出那么就返回 0。 解法： class S...
深入理解JAVA：OpenJDK JDK源码解读
3. **类和接口**：源码中的每个Java文件都定义了一个类或接口，类中包含了属性（fields）、方法（methods）和构造函数（constructors）。 4. **注释和文档**：良好的源码会包含大量的注释和文档，它们提供了代码的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值