精华内容
下载资源
问答
  • JAVA的移位运算

    2017-11-19 18:38:06
    java的移位运算在学习移位运算之前,移位只用于整数,我们首先应该知道计算机对数字是如何存贮的,在计算机中正数使用的原码存贮的,而负数则使用的是补码,补码等于原码取反(符号位不变)+1, java的移位运算符有...

    java的移位运算

    在学习移位运算之前,移位只用于整数,我们首先应该知道计算机对数字是如何存贮的,在计算机中正数使用的原码存贮的,而负数则使用的是补码,补码等于原码取反(符号位不变)+1,
    java的移位运算符有三种:<<=左移操作符,低位补0,>>=右移操作符,是正数,则在高位补0,是负数则在高位补1,>>>无符号右移操作符,无论正符都在高位补0,
    操作符的用法:操作符左边的值会移动由右边的值指定的位数,在把移动后的值赋给左边的变量。
    这里有一个值得注意点的:在thinking in java关于移位中有这么一段话

    If you shift a char, byte, or short, it will be promoted to int before the shift takes place, and the result will be an int.2) Only the five low-order bits of the right-hand side will be used.This prevents you from shifting more than the number of bits in an int. If you’re operating on a long, you’ll get a long result. Only the six low-order bits of the right-hand side will be used, so you can’t shift more than the number of bits in a long.

    如果对char、byte或者short类型的数值进行移位处理,那么在移位进行之前,它们会被转换为int类型,并且得到的结果也是一个int类型的值。只有数值右端的低5位才有用。这样可防止我们移位超过int型值所具有的位数。(译注:因为2的5次方为32,而int型数值只有32位。)若对一个long类型的数值进行处理,最后得到的记过也是long。此时只会用到数值右端的低6位,以防止移位超过long型数值具有的位数。

    有人数值右端的低5位才有用这句话不理解,其实意思是指,如果数值是int类型,移位运算等号右端的值只有低5位才有效,因为int是32为的2的5次方是32,如果等号右边的值超过32就会对32取余。long类型同理。

    public static void main(String[] args){
            int i = -1;
            System.out.println(Integer.toBinaryString(i));
            i>>>=10;
            System.out.println(Integer.toBinaryString(i));
            System.out.println(i);
            i = -1;
            System.out.println(Integer.toBinaryString(i));
            i >>>= 33;
            System.out.println(Integer.toBinaryString(i));
            System.out.println(i);
            short j = -1;
            System.out.println(Integer.toBinaryString(j));
            j >>>=10;
            System.out.println(Integer.toBinaryString(j));
            System.out.println(j);
    
        }
    
    展开全文
  • Java的移位运算

    万次阅读 2020-11-01 01:14:28
    而右移位运算却分为两种情况,分别是逻辑右移和算术右移(也叫无符号右移和符号右移),在逻辑右移中,会对操作数舍弃最低k位,并在左端补k个0,在算术运算中,则对操作数舍弃最低k位,并在左端补k个最高有效位...

    前言

    计算机支持两种移位运算,假设操作数为x,移动的位数为k,则向左移位是 x << k,向右移位是 x >> k。左移位会对输入的操作数舍弃最高的k位,并在右端补k个0。而右移位运算却分为两种情况,分别是逻辑右移和算术右移(也叫无符号右移和符号右移),在逻辑右移中,会对操作数舍弃最低的k位,并在左端补k个0,在算术运算中,则对操作数舍弃最低的k位,并在左端补k个最高有效位的值。

    对于有符号数来说,最高位有效值是不同的,所以逻辑右移和算术右移将产生不同的效果,而C语言并没有明确定义有符号数该使用哪种类型的右移,虽然两种右移都可以,但是现在几乎所有的编译器/机器组合都会对有符号数使用算术右移。而Java比C强大的一个地方在于它对右移有明确的定义,规定 x >> k 使用算术右移, x >>> k 使用逻辑右移。

    本文将通过几个实际的例子,并手动计算二进制执行过程,来探究当操作数分别为正数和负数时,Java的移位运算是怎么实现的。

    左移位运算

    左移运算也相当于做乘法运算,乘积因子为 2^k。例如,我们执行149 << 4,相当于执行了 149*16 = 2384。

    1)正数左移位运算

    System.out.println (149 << 4);
    System.out.println (Integer.toBinaryString ( 149 << 4 ));
    2384
    100101010000

    149 << 4 的计算过程如下:

    输入:            149

    转为二进制: 10010101

    展开32位:       00000000 00000000 00000000 10010101

    丢弃最高4位:  0000 00000000 00000000 10010101

    右端补4个0: 0000 00000000 00000000 10010101 0000

    忽略符号位: 10010101 0000

    转为十进制: 2384

    可以看出,我们计算过程的最后两步和程序打印效果完全一致。

    2)负数左移位运算

    System.out.println (-149 << 4);
    System.out.println (Integer.toBinaryString ( -149 << 4 ));
    -2384
    11111111111111111111011010110000

    -149 << 4 的计算过程如下:

    输入:            -149

    转为二进制: 11111111 11111111 11111111 01101011         (ps: 绝对值二进制取反再加1。)

    丢弃最高4位:  1111 11111111 11111111 01101011

    右端补4个0: 1111 11111111 11111111 01101011 0000

    以上是个负数二进制,现要转成十进制,按照以下三步进行:

                           1111 11111111 11111111 01101010 1111      (减1)

                           0000 00000000 00000000 10010101 0000(取反)

                          -10010101 0000                                           (忽略符号位,并添负号)

    转为十进制: -2384

    可以看出,我们计算过程的第4步和最后一步的计算结果和程序打印效果完全一致。

    右移位运算

    左移运算也相当于做乘法运算,被除数为 2^k。例如,我们执行149 >> 4,相当于执行了 149/16 = 9。

    1)正数右移运算

    Java的基本类型数据都是有符号数,最高位为1表示负数,最高位为0表示正数。所以对于正数来说,逻辑右移和算术右移没有任何区别,因为都是在左端补0。

    System.out.println (149 >> 4);
    System.out.println (Integer.toBinaryString ( 149 >> 4 ));
    System.out.println (149 >>> 4);
    System.out.println (Integer.toBinaryString ( 149 >>> 4 ));
    9
    1001
    9
    1001

    149 >> 4 计算过程:

    输入:            149

    转为二进制: 10010101

    展开32位:     00000000 00000000 00000000 10010101

    丢弃最低4位:00000000 00000000 00000000 1001

    左端补4个0:  0000 00000000 00000000 00000000 1001

    忽略符号位:  1001

    转为十进制:  9

    149 >>> 4 的计算过程和上面完全一样,左端都是补4个0,所以打印效果当然是一致的。

    2)负数右移运算

    当输入的数据是负数,此时逻辑右移和算术右移将产生较大区别。由于负数高位是1,所以逻辑右移和算术右移在左端分别补0和1。

    System.out.println (-149 >> 4 );  //负数的算术右移
    System.out.println (Integer.toBinaryString ( -149 >> 4 ));
    System.out.println (-149 >>> 4 ); //负数的逻辑右移
    System.out.println (Integer.toBinaryString ( -149 >>> 4 ));
    -10
    11111111111111111111111111110110
    268435446
    1111111111111111111111110110

    a)-149 >> 4 计算过程(负数的算术右移):

    输入:           -149

    转为二进制:   11111111 11111111 11111111 01101011         (ps: 绝对值二进制取反再加1。)

    丢弃最低4位: 11111111 11111111 11111111 0110

    左端补4个1:1111 11111111 11111111 11111111 0110

    相应十进制:  -0000 00000000 00000000 00000000 0101   (ps: 减1,取反,添负号。)

    转为十进制:-10

    可以看出,我们第4步和第6步运算结果和代码打印的前两行完全一致。

    b)-149 >>> 4 计算过程(负数的逻辑右移):

    输入:               -149

    转为二进制:    11111111 11111111 11111111 01101011       (ps: 绝对值二进制取反再加1。)

    丢弃最低4位:  11111111 11111111 11111111 0110

    左端补4个0: 0000 11111111 11111111 11111111 0110

    转为十进制: 268435446

    可以看出,我们第3步和第5步运算结果和代码打印的后两行完全一致。

    展开全文
  • java的移位运算

    2013-05-15 14:42:39
    java的移位运算~ java中的移位运算符有三种:(带符号右移)和>>>(无符号右移)。 1、 左移运算符 左移运算符
    java中的移位运算~
    java中的移位运算符有三种:<<(左移)、>>(带符号右移)和>>>(无符号右移)。
    1、 左移运算符
    左移运算符<<使指定值的所有位都左移规定的次数。
    1)它的通用格式如下所示:
    value << num
    num 指定要移位值value 移动的位数。
    左移的规则只记住一点:丢弃最高位,0补最低位
    如果移动的位数超过了该类型的最大位数,那么编译器会对移动的位数取模。如对int型移动33位,实际上只移动了33%32=1位。

    2)运算规则
    按二进制形式把所有的数字向左移动对应的位数,高位移出(舍弃),低位的空位补零。
    当左移的运算数是int 类型时,每移动1位它的第31位就要被移出并且丢弃;
    当左移的运算数是long 类型时,每移动1位它的第63位就要被移出并且丢弃。
    当左移的运算数是byte 和short类型时,将自动把这些类型扩大为 int 型。

    3)数学意义
    在数字没有溢出的前提下,对于正数和负数,左移一位都相当于乘以2的1次方,左移n位就相当于乘以2的n次方

    4)计算过程:
    例如:3 <<2(3为int型)
    1)把3转换为二进制数字0000 0000 0000 0000 0000 0000 0000 0011,
    2)把该数字高位(左侧)的两个零移出,其他的数字都朝左平移2位,
    3)在低位(右侧)的两个空位补零。则得到的最终结果是0000 0000 0000 0000 0000 0000 0000 1100,
    转换为十进制是12。
    移动的位数超过了该类型的最大位数,
    如果移进高阶位(31或63位),那么该值将变为负值。下面的程序说明了这一点:

    Java代码

    // Left shifting as a quick way to multiply by 2.
    public class MultByTwo {
    public static void main(String args[]) {
    int i;
    int num = 0xFFFFFFE;
    for(i=0; i<4; i++) {
    num = num << 1;
    System.out.println(num);
    }
    }
    }


    该程序的输出如下所示:

    536870908
    1073741816
    2147483632
    -32
    注:n位二进制,最高位为符号位,因此表示的数值范围-2^(n-1) ——2^(n-1) -1,所以模为2^(n-1)。

    2、 右移运算符
    右移运算符<<使指定值的所有位都右移规定的次数。
    1)它的通用格式如下所示:
    value >> num
    num 指定要移位值value 移动的位数。
    右移的规则只记住一点:符号位不变,左边补上符号位

    2)运算规则:
    按二进制形式把所有的数字向右移动对应的位数,低位移出(舍弃),高位的空位补符号位,即正数补零,负数补1
    当右移的运算数是byte 和short类型时,将自动把这些类型扩大为 int 型。
    例如,如果要移走的值为负数,每一次右移都在左边补1,如果要移走的值为正数,每一次右移都在左边补0,这叫做符号位扩展(保留符号位)(sign extension ),在进行右移

    操作时用来保持负数的符号。


    3)数学意义
    右移一位相当于除2,右移n位相当于除以2的n次方。

    4)计算过程
    11 >>2(11为int型)
    1)11的二进制形式为:0000 0000 0000 0000 0000 0000 0000 1011
    2)把低位的最后两个数字移出,因为该数字是正数,所以在高位补零。
    3)最终结果是0000 0000 0000 0000 0000 0000 0000 0010。
    转换为十进制是3。

    35 >> 2(35为int型)
    35转换为二进制:0000 0000 0000 0000 0000 0000 0010 0011
    把低位的最后两个数字移出:0000 0000 0000 0000 0000 0000 0000 1000
    转换为十进制: 8

    5)在右移时不保留符号的出来
    右移后的值与0x0f进行按位与运算,这样可以舍弃任何的符号位扩展,以便得到的值可以作为定义数组的下标,从而得到对应数组元素代表的十六进制字符。
    例如
    Java代码 [url=][/url]

    public class HexByte {
    public static public void main(String args[]) {
    char hex[] = {
    '0', '1', '2', '3', '4', '5', '6', '7',
    '8', '9', 'a', 'b', 'c', 'd', 'e', 'f''
    };
    byte b = (byte) 0xf1;
    System.out.println("b = 0x" + hex[(b >> 4) & 0x0f] + hex[b & 0x0f]);
    }
    }


    (b >> 4) & 0x0f的运算过程:
    b的二进制形式为:1111 0001
    4位数字被移出:0000 1111
    按位与运算:0000 1111
    转为10进制形式为:15

    b & 0x0f的运算过程:
    b的二进制形式为:1111 0001
    0x0f的二进制形式为:0000 1111
    按位与运算:0000 0001
    转为10进制形式为:1

    所以,该程序的输出如下:
    b = 0xf1


    3、无符号右移
    无符号右移运算符>>>
    它的通用格式如下所示:
    value >>> num
    num 指定要移位值value 移动的位数。
    无符号右移的规则只记住一点:忽略了符号位扩展,0补最高位
    无符号右移运算符>>> 只是对32位和64位的值有意义

    例题~
    猴子吃桃问题:猴子第一天摘下若干个桃子,当即吃了一半,还不瘾,又多吃了一个 第二天早上又将剩下的桃子吃掉半,又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时,见只剩下一个桃子了。求第一天共摘了多少。
    public static long getPeach_Num3(int day) { return 3*(1<<(day-1))-2;// 这是用数学归纳出来的方法,1<<day,表示2的day次方。 }
    展开全文
  • Java 的移位运算

    千次阅读 2016-06-15 14:17:01
    在Think in Java中有这么一段话“对char,byte或者short进行移位处理,那么在移位进行之前,它们会自动转换成一个int。只有右侧5个低位才会有用。这样可防止我们在一个int数里移动不切实际位数。若对一个long值...

    在Think in Java中有这么一段话“对char,byte或者short进行移位处理,那么在移位进行之前,它们会自动转换成一个int。只有右侧的5个低位才会有用。这样可防止我们在一个int数里移动不切实际的位数。若对一个long值进行处理,最后得到的结果也是long。此时只会用到右侧的6个低位,防止移动超过long值里现成的位数。”

    这段话有两个出处,一个是Java编程思想3.11移位操作符中出现,原话是“只有数值右端的低5位才有用”。一个是Java解惑中谜题27:变幻莫测的i值,原话是“移位操作符只使用其右操作数的低5位作为移位长度

    弄清这句话首先需要弄清楚移位操作符,移位操作符是一个二元操作符,两个操作数分别位于移位操作两边形如:左操作数 移位操作符 右操作数 这样的结构,其含义是,将左操作数按照移位操作符指定的移位方向,进行右操作数指定的次数的移位。然后对照出处二,Java解惑中所描述的,就豁然开朗了。

    首先,移位操作符能操作的数只有int类型和long类型,这个是指左操作数的类型。对于int类型而言,intJava中占4字节,一共32位,也就是说,对于一个在Java中的int数据,做32次移位,那么这个int数据就完全变了,以左移为例,左移是补0,那么对于任意一个int类型数据,做32次移位,那么int数据变成32位全0的数据,Java不允许一次性移位左操作数的所有位,也就是右操作数不能大于32。于是回到上述的句子,其指的是右操作数的低5位,5位二进制所代表的最大值为2^5-1,为31,所以取右操作数的低5位,就是只看右操作数的二进制的低5位,其数值不会超过2^5次方,也就是int32位。因此,移位操作符进行移位的实际次数,其实是右操作数2的次数。


    对上面那段话的理解是:移位操作符操作的运算对象是二进制的“位”,int类型是32位也就是2的5次幂 !如果移32位以上,那么原来的数的信息会全部丢失,这样也就没有什么意义了!所以上面的“只有右侧的5个低位才会有用”说的是:移位操作符右端的那个数(化成二进制)的低5位才有用,即
    X < <y;

    是指y的低5位才有用,即不能大于32。 而对于long型也是同样的道理!



    因此,如果对一个int 型,进行移位,X < <y; 当y小于32时,移位后的结果一般都在我们的预料当中;而如果y大于32时,由于移位超出了int所能表示的范围,这时就先把y化成二进制数,然后取该二进制数右端的低5位,再把这5位化成十进制,此时的这个十进制就是要对X移动的位数。
    例如: int int a=140;
    a << 34
    System.out.println(Integer.toBinaryString(a << b));
    上面那两个语句的执行过程是:先把a化成二进制数:10001100

    执行语句 a << 34 对a左移32位时,先把 34化成二进制:100010,对该二进制数取右边5位,即00010,化成十进制数为2,所以实际上是对a左移两位。现在,地球人都会知道上面程序的输出结果是:1000110000

    //
    移位运算符和按位运算符一样,同属于位运算符,因此移位运算符的位指的也是二进制位。它包括以下几种:
    左移位(<<):将操作符左侧的操作数向左移动操作符右侧指定的位数 。移动的规则是在二进制的低位补0。 有符号右移位(>>):将操作符左侧的操作数向右移动操作符右侧指定的位数。移动的规则是,如果被操作数的符号为正,则在二进制的高位补0;如果被操作数的符号为负,则在二进制的高位补1。 无符号右移位(>>>):将操作符左侧的操作数向右移动操作符右侧指定的位数。移动的规则是,无论被操作数的符号是正是负,都在二进制位的高位补0。
    注意,移位运算符不存在“无符号左移位(<<<)”一说。与按位运算符一样,移位运算符可以用于byte、short、int、long等整数类型,和字符串类型char,但是不能用于浮点数类型float、double;当然,在Java5.0及以上版本中,移位运算符还可用于byte、short、int、long、char对应的包装器类。我们可以参照按位运算符的示例写一个测试程序来验证,这里就不再举例了。
    与按位运算符不同的是,移位运算符不存在短路不短路的问题。
    写到这里就不得不提及一个在面试题中经常被考到的题目:
    引用
    请用最有效率的方法计算出2乘以8等于几?
    这里所谓的最有效率,实际上就是通过最少、最简单的运算得出想要的结果,而移位是计算机中相当基础的运算了,用它来实现准没错了。左移位“<<”把被操作数每向左移动一位,效果等同于将被操作数乘以2,而2*8=(2*2*2*2),就是把2向左移位3次。因此最有效率的计算2乘以8的方法就是“2<<3”。
    最后,我们再来考虑一种情况,当要移位的位数大于被操作数对应数据类型所能表示的最大位数时,结果会是怎样呢?比如,1<<35=?呢?
    这里就涉及到移位运算的另外一些规则:
    byte、short、char在做移位运算之前,会被自动转换为int类型,然后再进行运算。 byte、short、int、char类型的数据经过移位运算后结果都为int型。 long经过移位运算后结果为long型。 在左移位(<<)运算时,如果要移位的位数大于被操作数对应数据类型所能表示的最大位数,那么先将要求移位数对该类型所能表示的最大位数求余后,再将被操作数移位所得余数对应的数值,效果不变。比如1<<35=1<&lt;(352)=1<<3=8。 对于有符号右移位(>>)运算和无符号右移位(>>>)运算,当要移位的位数大于被操作数对应数据类型所能表示的最大位数时,那么先将要求移位数对该类型所能表示的最大位数求余后,再将被操作数移位所得余数对应的数值,效果不变。。比如100>>35=100>>(352)=100>>3=12。


    另:

    Java 的 Integer.toBinaryString 方法

    public static String toBinaryString(int i)
    
        //以二进制(基数 2)无符号整数形式返回一个整数参数的字符串表示形式。 
        //如果参数为负,该无符号整数值为参数加上 2^32;否则等于该参数。
    
            System.out.println(Integer.toBinaryString(-1)) ;
            System.out.println(Integer.toBinaryString(2)) ;
            System.out.println(Integer.toBinaryString(1)) ;
    
        输出:
            11111111111111111111111111111111
            11111111111111111111111111111110
            1
    结论输出的是数字的二进制补码。为什么说是以 二进制无符号整数形式 返回一个 整数类型的字符串,为什么 如果参数为负数,就要加上 232 次方

    因为Java里的int是有符号的,在内存中没有正负之分,只有0/1,整数是用补码表示的

    正数补码等于原码
    负数的补码等于其绝对值的反码+1,正好等于自身+2^32(对于4字节的整型来说)

    -1 的补码 就是 绝对值1 的反码(按位取反) 11111111 11111111 11111111 11111110 再+1
    等于 11111111 11111111 11111111 11111111

    这样正好能把最高位为1的数字用来表示负数,而最高位为0的数字表示非负数

    10000000 00000000 00000000 00000000 => -2147483648
    11111111 11111111 11111111 11111111 => -1
    00000000 00000000 00000000 00000000 => 0
    00000000 00000000 00000000 00000001 => 1
    01111111 11111111 11111111 11111111 => 2147483647
    

    因此负数+2^32之后的二进制串,就是该负数内存中准确的存储形式

    参考、转载:

    http://blog.sina.cn/dpool/blog/s/blog_6f436a590100nc37.html?vt=4

    https://segmentfault.com/q/1010000002535852

    http://blog.sina.com.cn/s/blog_6ca0f5eb0102vlha.html


    展开全文
  • 对byte 和short类型值进行移位运算的结果是int 型,而且如果左移不超过31位,原来对应各位值也不会丢弃。但是,如果你对一个负byte 或者short类型值进行移位运算,它被扩大为int 型后,它符号也被扩展。...
  • 在实际 开发中,其实很少 使用 移位...特别是 还用 移位运算 实现 高性能 乘法与除法。 虽然知道,但是还是有点蒙,或者说 不知道应该怎么用 除法 >> int a = 10; int c = a >> 1; System.o...
  • java的移位运算实例

    2014-09-18 16:25:57
    public class StrToByte { /** * 将yyMMddhhmmss格式日期字符串转换成byte[] * 其中yy取最大为62即2000--2062 * * @author linfenliang * @date 2012-6-19 * @version V1.0.0 * @param dateStr * :日期字符串 * @...
  • java的移位运算和位运算

    千次阅读 2013-10-04 20:17:50
    * @(#)Test.java * * Test application * * @author * @version 1.00 2013/10/4 */ public class Test { public static void main(String[] args) { int a=1>>2; int b=-1>>2;
  • 1)java中无符号右移:>>>,下面是一个int型负数,然后每次移动一位。 int k = -0x123;System.out.println(Integer.toBinaryString(k));int n = k>>>1;System.out.println(Integer....
  • System.out.print("您输入是错误,请重新输入:"); } } // 下面一步编译不通过。什么原因。该如何解决 int result = (schedule >> shift) & 0x01; if(1 == result) System....
  • java的移位运算

    2018-08-02 00:22:31
    1.java的移位运算面向的运算对象是二进制的“位”,有“&lt;&lt;(左移位运算)”、“&gt;&gt;(右移位运算)”、“&gt;&gt;&gt;(无符号右移运算)”  2. "&lt;&lt;&...
  • Java移位运算

    2018-08-23 17:19:28
    主要讲述Java移位运算,包括:基本数据类型范围、二进制概念,移位运算符,基本数据类型与二进制之间转换等。
  • 今天小编就为大家分享一篇关于Java利用移位运算将int型分解成四个byte型方法,小编觉得内容挺不错,现在分享给大家,具有很好参考价值,需要朋友一起跟随小编来看看吧
  • Java移位运算

    千次阅读 2017-07-09 15:59:13
    以前一直没有研究二进制的移位运算的应用场景是什么,怎么运算?怎么实现数据的四则运算的? 直到最近,在看Think in Java的书籍,才真正理解这个东西。下面记录一下学习笔记。 1,二进制1.1 二进制的表示我们知道...
  • java的移位运算

    2008-12-26 10:45:32
    java的移位运算(groovy与java一样) Java中的移位,如果是short,char,byte的话,都会转换成int的形式 再进行移位的。 试看: 1.) byte a = 27;// 转换成int为 00000000000000000000000000011011 byte b...
  • Java移位运算的应用

    2019-07-31 01:50:16
    大家都知道计算机最擅长就是计算,但是你知道计算机是如何在极短时间内计算出庞大数值吗? 首先看一下这个式子: 324364657365 * 1000000000 如果把这个数字交给计算机算话,计算机如何计算,计算机最...
  • Java移位运算

    2016-08-07 17:11:33
    Java位运算符一、什么是位运算符程序中所有数在计算机内存中都是以二进制形式储存。位运算说穿了,就是直接对整数在内存中二进制位进行操作。比如,and运算本来是一个逻辑运算符,但整数与整数之间也可以...
  • Java_移位运算

    2016-03-11 16:41:30
    java移位运算符不外乎就这三种:>(带符号右移)和>>>(无符号右移)  1、 左移运算符 左移运算符 1)它通用格式如下所示: value num 指定要移位值value 移动位数。 左移规则只记住一点:丢弃最高位,0补...
  • Java的移位运算

    2020-04-15 16:24:46
    Java的移位运算<<>>>>>移位运算结果 << <<: 左移运算,左移几位就补几个0 >> >>: 右移运算,为算术右移 如果数字为正数时,移位后在前面补0 如果数字为负数时,移位...
  • java 左右移位运算

    2015-08-01 17:01:00
     num 指定要移位值value 移动位数。  左移规则只记住一点:丢弃最高位,0补最低位  如果移动位数超过了该类型最大位数,那么编译器会对移动位数取模。如对int型移动33位,实际上只移动了332=1位...
  • java移位运算

    2020-12-01 21:21:25
    java移位运算 int A=60;//(即二进制00111100) 有符号数移位 “<<” 按位左移运算符, 左操作数按位左移右操作数指定位数,将该数乘以2^n,n为移位位数。 A << 2 //得到240,将00111100向左移两...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,243
精华内容 497
关键字:

java的移位运算

java 订阅