精华内容
下载资源
问答
  • 使用位运算&取余
    千次阅读
    2021-03-10 08:15:35

    取余运算符为“%”。但在以前,CPU采用如下方法计算余数(注意,该方法只对2的N次方数系有效):

    X & (2^N - 1)

    举个例子:

    9 % 4 //因为4是2^2;所以可以使用位运算X & (2^N - 1)代替取余

    = 9 & ( 4 - 1 )

    = 9 & 3

    = 1001 & 0011

    = 0001

    = 1

    原理:

    二进制数乘以2^n,相当于左移n位;

    二进制数除以2^n,相当于右移n位;

    任何二进制数和1的&操作,还是原来的二进制数

    举个例子:

    9 转换为二进制为 1001

    1001 = 1*2^3 + 0*2^2 + 0*2^1 + 1*2^0

    那么:

    1001 * 2^1

    = (1*2^3 + 0*2^2 + 0*2^1 + 1*2^0)* 2^1

    = 2*2^3 + 0*2^2 + 0*2^1 + 2*2^0

    = 2^4 + 0*2^3 + 0*2^2 + 1*2^1 + 0*2^0

    = 10010

    可知 1001*2,相当于将1001左移一位变成10010

    1001 / 2^1

    = (1*2^3 + 0*2^2 + 0*2^1 + 1*2^0)/ 2^1

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

    = 100

    可知 1001 / 2,相当于将1001右移一位变成100,而且可以知道右移出去的1就是1001 / 2的余数

    任意一个数转换成二进制,我们可以分别将它二进制的每一位(1或者0)去乘以 2^n (这里的n从右边开始数依次为 0、1、2 ......)

    我们用x表示一个普通的 n 位二进制数的每一位(这个 x 不需要去纠结,它可以是1也可以是0,只是这么表示,对结果没有什么影响),如下:

    xx...xx = x*2^(n-1) + x*2^(n-2) +...+ x*2^1 + x*2^0

    这个数处以一个2^m次方

    xx...xx / 2^m

    = ( x*2^(n-1) + x*2^(n-2) +...+ x*2^1 + x*2^0 ) / 2^m

    = x*2^(n-1-m) + x*2^(n-1-m) +... + x*2^(m-m) + x*2^(m-1-m) + ... + x*2^(0-m)

    x*2^(m-m) = x*2^0 ,这就是所得二进制数的最低位,而其后面的那些项x*2^(m-1-m) + ... + x*2^(0-m)

    就是余数

    这里相当于把 xx...xx 右移了 m 位,而移出去的那 m 位,就是余数(因为前面的都可以整除,后面的是不可以整除的,就是余数)

    我们知道:

    二进制的 2^m -1,总共有m+1位, 除了最高位 m+1 位为0,其余 m 位都为1

    任何二进制数和1的&操作,原数都不变

    那么:

    xx...xx & (2^m -1) 相当于取出了xx...xx 的低 m 位二进制数,也就是上面所说的右移出去的那m位数,也就是余数

    更多相关内容
  • java位运算

    2021-02-28 19:22:32
    移动运算符:<例如:3 <<2(3为int型)1)把3转换为二进制数字0000 0000 0000 0000 0000 0000 0000 0011,2)把该数字高位(左侧)的两个零移出,其他的数字都朝左平移2,3)在低位(右侧)的两个空位补零。则...

    10d37a2be6813a312dc56985106dc829.png

    位移动运算符:

    <

    例如: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。

    同理,>>表示右移. 右移一位表示除2.

    位运算:

    位运算符包括: 与(&)、非(~)、或(|)、异或(^)

    &:当两边操作数的位同时为1时,结果为1,否则为0。如1100&1010=1000

    | :当两边操作数的位有一边为1时,结果为1,否则为0。如1100|1010=1110

    ~:0变1,1变0

    ^:两边的位不同时,结果为1,否则为0.如1100^1010=0110

    位运算与位移动运行符的一个场景:

    HashMap的功能是通过“键(key)”能够快速的找到“值”。下面我们分析下HashMap存数据的基本流程:

    1、当调用put(key,value)时,首先获取key的hashcode,int hash = key.hashCode();

    2、再把hash通过一下运算得到一个int h.

    hash ^= (hash >>> 20) ^ (hash >>> 12);

    int h = hash ^ (hash >>> 7) ^ (hash >>> 4);

    为什么要经过这样的运算呢?这就是HashMap的高明之处。先看个例子,一个十进制数32768(二进制1000 0000 0000 0000),经过上述公式运算之后的结果是35080(二进制1000 1001 0000 1000)。看出来了吗?或许这样还看不出什么,再举个数字61440(二进制1111 0000 0000 0000),运算结果是65263(二进制1111 1110 1110 1111),现在应该很明显了,它的目的是让“1”变的均匀一点,散列的本意就是要尽量均匀分布。

    3、得到h之后,把h与HashMap的承载量(HashMap的默认承载量length是16,可以自动变长。在构造HashMap的时候也可以指定一个长 度。这个承载量就是上图所描述的数组的长度。)进行逻辑与运算,即 h & (length-1),这样得到的结果就是一个比length小的正数,我们把这个值叫做index。其实这个index就是索引将要插入的值在数组中的 位置。第2步那个算法的意义就是希望能够得出均匀的index,这是HashTable的改进,HashTable中的算法只是把key的 hashcode与length相除取余,即hash % length,这样有可能会造成index分布不均匀。还有一点需要说明,HashMap的键可以为null,它的值是放在数组的第一个位置。

    4、我们用table[index]表示已经找到的元素需要存储的位置。先判断该位置上有没有元素(这个元素是HashMap内部定义的一个类Entity, 基本结构它包含三个类,key,value和指向下一个Entity的next),没有的话就创建一个Entity对象,在 table[index]位置上插入,这样插入结束;如果有的话,通过链表的遍历方式去逐个遍历,看看有没有已经存在的key,有的话用新的value替 换老的value;如果没有,则在table[index]插入该Entity,把原来在table[index]位置上的Entity赋值给新的 Entity的next,这样插入结束。

    附:hashmap是列表与链表的结合体.

    参:http://www.cnblogs.com/highriver/archive/2011/08/15/2139462.html

    ----------------------------------------------------------------------------

    转自http://www.iteye.com/topic/766461

    移位运算符

    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位),那么该值将变为负值。下面的程序说明了这一点:

    // 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 <

    System.out.println(num);

    }

    }

    }

    // 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。

    转换为十进制是2。

    35 >> 2(35为int型)

    35转换为二进制:0000 0000 0000 0000 0000 0000 0010 0011

    把低位的最后两个数字移出:0000 0000 0000 0000 0000 0000 0000 1000

    转换为十进制: 8

    5)在右移时不保留符号的出来

    右移后的值与0x0f进行按位与运算,这样可以舍弃任何的符号位扩展,以便得到的值可以作为定义数组的下标,从而得到对应数组元素代表的十六进制字符。

    例如

    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]);

    }

    }

    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位的值有意义

    展开全文
  • Java位运算基础知识

    2021-02-13 00:16:59
    Java运算位运算都是针对整数的补码进行位运算。& 按位与运算先将整数转换为补码 ,然后执行按位与运算,最后将结果返回为十进制,它有如下几个规律:(1)正数&其他数=正数 考虑最高位为0,按位与都为0(2)...

    在学习Java运算时,补充学习Java位运算。

    Java位运算

    位运算都是针对整数的补码进行位运算。

    & 按位与运算

    先将整数转换为补码 ,然后执行按位与运算,最后将结果返回为十进制,它有如下几个规律:

    (1)正数&其他数=正数 考虑最高位为0,按位与都为0

    (2)偶数&其他数=偶数 考虑最低位为0,按位与都为0

    (3)0&其他数=0 按位与后位数全是0

    (4)1&奇数=1,1&偶数=0 通过它可以快速判断一个数是奇数还是偶数

    | 按位或运算

    先将整数转换为补码 ,然后执行按位或运算,最后将结果返回为十进制,它有如下几个规律:

    (1)负数|其他数=负数 考虑最高位为1,按位或都为1

    (2)奇数|其他数=奇数 考虑最低位为1,按位或都为1

    (3)0|其他数=原数 按位或后位数不变

    ^ 按位异或运算

    先将整数转换为补码 ,然后执行按异位或运算,最后将结果返回为十进制,它有如下几个规律:

    (1)偶数^偶数=偶数 考虑最低位为0,按位异或为0

    (2)偶数^奇数=奇数 考虑最低位为1和0,按位异或为1

    (3)奇数^奇数=偶数 考虑最低位为1,按位异或为0

    (4)a^b^b或者b^a^b=a b^b=0,然后其他数异或一个0,就是原数

    示例代码

    1 public classOperatorAndOrXor{2 public static voidmain(String[] args){3 //测试按位与运算

    4 int a=9;5 int b=11;6 System.out.println(a&b);//97

    8 //测试按位或运算

    9 System.out.println(a|b);//1110

    11 //测试按位异或运算

    12 System.out.println(a^b);//2

    13 System.out.println(a^b^b);//9

    14 }15 }

    测试结果

    121af7bc9c5712c95e94d8fd2eaffaf7.png

    << 左移

    数据左移,先将其转换为补码,然后向左移动相应位次,移出的部分舍弃,低位空出补0,最后转换为十进制,左移动几位相当于乘以2的几次方,如byte类型1左移3位,就是从0000 0001→0000 1000,变成了8。

    >> 右移

    数据右移,先将其转换为补码,然后向右移动相应位次,移出的部分舍弃,高位空出有两种情况,如果是正数高位补0,负数则高位补1,最后转换为十进制,一定范围内,右移动几位相当于除以2的几次方,如byte类型8右移3位,就是从0000 1000→0000 0001,变成了1。

    此外正数右移动,越移动0越多,如byte类型最后补码变成0000 0000,转换成原码也是0000 0000,最小变成0。

    负数右移动,越移动1越多,如byte类型,最后补码变成1111 1111,转换成反码为1111 1110,再转换为原码变成1000 0001,最后结果变成-1。

    >>> 无符号右移动

    无符号右移,先将其转换为补码,然后向右移动相应位次,移出的部分舍弃,高位空出不论正负数一律补0,最后转换为十进制。可以看出正数的无符号右移动和右移没有区别,负数就有区别了,负数的无符号右移>>>运算会变成正数,且负数越大,补码中1越多,无符号右移后正数越大。

    ~ 按位取反

    将数据转换为补码后,一律1变0,0变1,最后将结果转换为十进制,按位取反有互补对称公式-n=~n+1。

    代码部分

    1 public classMoveMethod{2 public static voidmain(String[] args){3 //测试左移、右移、无符号右移、取反运算4 //左移

    5 int i=1;6 System.out.println(i<<3);//87

    8 //右移

    9 int j=8;10 System.out.println(j>>3);//111

    12 //左移右移很大位数

    13 System.out.println(i<<35);//8

    14 System.out.println(j>>35);//115

    16 //无符号右移

    17 System.out.println(j>>>3);//1

    18 int k=-1;19 System.out.println(k>>>1);//负数变成正数20

    21 //取反 -n=~n+1

    22 System.out.println(~j);//-9

    23 System.out.println(~k);//0

    24 }25 }

    测试结果

    0339202ef316039216788cbbf0272530.png

    需要注意的是,移位运算不是直接移动相应的位数,而是先将位数对32取余,对余数对应的数进行相应位次的移动。如1<<35=1<

    按位异或用于交换整数

    按位异或的特点可以用在整数交换上面,除了按位异或交换,还有其他两种交换方式。

    1 public classChangeMethod{2 public static voidmain(String[] args){3 //交换值的三种方式4 //option1 按位异或交换,用于整数

    5 int a=5;6 int b=7;7 a=a^b;8 b=a^b;//b=a^b^b=a

    9 a=a^b;//a=a^b^a=b^a^a=b

    10 System.out.println(a);11 System.out.println(b);12

    13 //option2 加减法交换,用于所有数值,除了整数还可以用其他数

    14 int x=5;15 int y=7;16 x=x+y;17 y=x-y;//y=x+y-y=x

    18 x=x-y;//x=x+y-x=y

    19 System.out.println(x);20 System.out.println(y);21

    22 //option3 中间值交换,也叫做追尾法交换,适用所有类型

    23 int i=5;24 int j=7;25 int temp=i;26 i=j;27 j=temp;28 System.out.println(i);29 System.out.println(j);30

    31 }32 }

    交换结果

    810e2d3ef317554e57ebfa0366b3cbd3.png

    以上三种交换方式各有优缺点,总结就是以下几点,异或法效率最好,追尾法效率最低,使用频率上异或法最低,追尾法最高。

    总结

    (1)位运算目前学的一共有7种,进行运算时都需要转换为补码进行移动。

    (2)按位异或位运算可以用于交换两个整数。

    参考博文:

    展开全文
  • 1.^(亦或运算) ,针对二进制,相同的为0,不同的为1public static void main(String[] args) {System.out.println("2^3运算的结果是 :"+(2^3));//打印的结果是: 2^3运算的结果是 :1}2 =======>00103 =======>...

    1.^(亦或运算) ,针对二进制,相同的为0,不同的为1

    public static void main(String[] args) {

    System.out.println("2^3运算的结果是 :"+(2^3));

    //打印的结果是: 2^3运算的结果是 :1

    }

    2 =======>0010

    3 =======>0011

    2^3就为0001,结果就是1

    2.&(与运算)针对二进制,只要有一个为0,就为0

    还是上述的例子

    public static void main(String[] args) {

    System.out.println("2&3运算的结果是 :"+(2&3));

    //打印的结果是:   2&3运算的结果是 :2

    }

    3.<

    public static void main(String[] args) {

    System.out.println("2<<3运算的结果是 :"+(2<<3));

    //打印的结果是:   2<<3运算的结果是 :16

    }

    4.>>(向右位移) 针对二进制,转换成二进制后向右移动3位,

    public static void main(String[] args) {

    System.out.println("2>>3运算的结果是 :"+(2>>3));

    //打印的结果是:   2>>3运算的结果是 :0

    }

    5.>>>(无符号右移)无符号右移,忽略符号位,空位都以0补齐

    10进制转二进制的时候,因为二进制数一般分8位、 16位、32位以及64位 表示一个十进制数,所以在转换过程中,最高位会补零。

    在计算机中负数采用二进制的补码表示,10进制转为二进制得到的是源码,将源码按位取反得到的是反码,反码加1得到补码

    二进制的最高位是符号位,0表示正,1表示负。

    >>>与>>唯一的不同是它无论原来的最左边是什么数,统统都用0填充。

    ——比如,byte是8位的,-1表示为byte型是11111111(补码表示法)

    b>>>4就是无符号右移4位,即00001111,这样结果就是15。

    下面看代码

    public static void main(String[] args) {

    System.out.println("16>>2运算的结果是 :"+((16)>>2));

    //打印的结果是:   16>>2运算的结果是 :4

    }

    public static void main(String[] args) {

    System.out.println("-16>>2运算的结果是 :"+((-16)>>2));

    //打印的结果是:   -16>>2运算的结果是 :-4

    }

    public static void main(String[] args) {

    System.out.println("16>>>2运算的结果是 :"+((16)>>>2));

    //打印的结果是:   16>>>2运算的结果是 :4

    }

    public static void main(String[] args) {

    System.out.println("-16>>>2运算的结果是 :"+((-16)>>>2));

    //打印的结果是:   -16>>>2运算的结果是 :1073741820

    }

    可见正数做>>>运算的时候和>>是一样的。区别在于负数运算

    快速算出移位运算符结果方法:

    在不大于自身数值类型最大位数的移位时,一个数移位n,就是将这个数乘以(左移)2的n次幂,右移就是除,然后都取整就可以了

    比如int 32位的

    500>>3 这样算:500/8 取整 就是62

    356>>4 356/16 结果是 22

    8<<3 8*8 结果是 64

    64位和上面方法一样。

    如果移动过大超过了32位怎么办 移位数和32取余得到的数字在套用上面就可以了

    比如 500>>67 怎么算?(就相当于500>>3)

    1.先67对32取余 结果是3

    2. 然后500/8 结果62

    计算机指令种的右移位运算符有2种,左移就是补0没花哨。但右移就有点事情了。

    1. 算术右移 意思是你移动后补的是最高位的值。

    举例:一个byte数字99 的二进制是 0110 0011

    你右移4位后 补的是0 ------0000 0110

    但是再看这一个:byte数字-107二进制是1001 0101 这是1开头的

    你右移4位后补的确是最高位1 -------1111 1001

    2.逻辑右移 补0就完事了

    针对右移,C语言美显示给出用哪种的,一般根据编译器/机器组合来确定用哪一种,但大多数都默认算术右移。

    JAVA就比较严谨了,明确规定x>>k是算术右移

    x>>>k是逻辑右移

    话说回来之所以区分这一点我想应该是对有符号的规定吧,无符号右移肯定是逻辑的啊 最高位本来就是0,然而对于负数最高位是1,在进行右移时算术右移的提出解决了一个很普遍的问题,那就是负整数的除法运算,你负数除以一个正数一定是负数吧,如果没有算数右移这一概念的提出不补1都补0的话你得到的就是正数了,算术右移可以替代除法运算。有了这个就完美了,得到的还是负数,符合现实中数学常识了

    展开全文
  • 主要介绍了Java别说取余(%)运算简单你真的会吗,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • concurrentHashMap分段锁原理,java8和java7实现的区别 B-树和B+树区别,数据库索引原理,组合索引怎么使用?最左匹配的原理 spring生命周期,几种scope区别,aop实现有哪几种实现,接口代理和类代理会有什么区别 ...
  • Java取余(%)运算规则

    千次阅读 2021-06-26 15:47:20
    Java取余(%)运算规则 本质:m % n = m - (int)(m / n) * n 注意:余值结果符号和 m (被模数) 符号有关,m为负数则余值为负数,m为正数则余值为正数。 适用类型 对于具有相同类型的两个变量m和n,取模运算适用于除了...
  • java 取余运算

    千次阅读 2019-07-01 10:46:24
    java中%的含义为取余java :a%b 数学公式a%b=a-(a/b)*b 其实还有一个非常简单的判定方法,如果能被取余的数整除,那么就是0,如果不行,取最接近的结果取剩下的数,就是余数。 比如: 24%8 余 0 25%8 余1 31%8 ...
  • Java中的取余运算规则

    千次阅读 2021-10-24 21:17:12
    要学会取余运算,我们得明白它其中的数学算法是如何表达的 a % b = a - (a / b) * b 5 % 3 = 5 -(5 / 3 )* 3 我们直接套用此数学公式即可得到结果,需要注意的是默认的double类型会造成损失精度。 举例: 3 ...
  • java - 神奇的取余运算

    千次阅读 2021-03-08 20:36:03
    整数取余运算中,除数为0,抛出一个ArithmeticException异常。 如: class Test { public static void main(String args[]) { System.out.println(3/0); System.out.println(3%0); } } 小数除法中,除数为0,输出一...
  • 今天来用2个实例来介绍下基础的取余“%”运算,一种是判断一个整型数字的奇偶性,另一种则是取个上的值。一、判断整型数字能被什么整除,例:判断数字的奇偶性:import java.util.Scanner;public class Test006 {...
  • java取余运算“%”

    2020-11-26 15:13:51
    @java取余运算“%” demo public static void main(String[] args) { System.out.println(5%3); System.out.println(-5%3); System.out.println(5%-3); System.out.println(-5%-3); } 运行结果 2 -2 2 -2 总结...
  • JAVA基础篇:取余运算取余运算简单快速理解 简单快速理解: 当除数与被除数的符号相同时,取余和取模的结果是完全相同的; 当除数与被除数的符号不相同时,结果不同。 具体说 取余结果的符号与被除数相同; ...
  • 位运算的效率是最高的,因为位位运算是直接对二进制进行操作位运算只能应用于整型和char类型(char类型可以看做是特殊的无符号的整形)面试题:a: 判断一个数是否是奇数a & 1 == 1;b: 对2 ^ n 取余。a & (2^n ...
  • * 使用位运算实现 加减乘除 取模 * 原理:加法原则:对应位置进行加和,若果有进位,则加到到高位中。 * 那么使用位运算代替加法,要解决两个问题: * 1、如何计算进位 * 二进制中出现进位的形式只有1+1,可以...
  • 之前大学里面学单片机的时候,由于内存以及处理器性能都极其有限(可能很多时候考虑内存的限制优先于处理器),所以很多时候,利用位运算来节约空间或者提高性能,那么这些优秀的思想,放到目前的Java中,是否还有必要...
  • java运算中的取余

    2022-05-17 07:43:13
    java运算中有时会出现对一个整数取余操作,首先复习一下小学学过的除法公式: 除数 ÷ 被除数 = 商 如果没有被整数就会出现余数,例:10 ÷ 3 = 3 余数为 1 在java运算中,取余符号是 % 1、第一种情况一个大的...
  • 没有测试过使用取余运算符和运算符都做同一件事时的时间效率!取余运算符%如3除以2取余数int a =a = a%;结果为1上面是传统的方式进行求余运算。需要先将10进制转成2进制到内存中进行计算,然后再把结果转换成10...
  • 一般情况下,编写web应用可能很少接触到位运算场景,但是一旦编写...由于java采用补码,如果需要得到正数的负数就需要将正数按取反再加1,可以验证-val=~val+1=-1。2、按异或(^)只有的值不同才等于1否则为0。...
  • Java中的取余运算和取模运算

    千次阅读 2017-05-16 18:15:03
    通常取模运算也叫取余运算,他们都遵循处罚法则,返回结果都是余数; 但是仔细看是不一样的,详细请看实例: 1.取余 rem(3,2)=1 rem(-3,-2)=-1 rem(3,-2)=1 rem(-3,2)=-1 2.取模 mod(3,2)=1 mod(-3,-2)=-1 mod(3,-2)...
  • Java取余运算

    2020-02-26 22:10:39
    Java运算都是以补码进行计算的,6的原码为 00000000 00000000 00000000 00000110,正数的补码 = 反码 = 原码 所以补码也是00000000 00000000 00000000 00000110,然后进行取反操作变成了 11111111 11111111 ...
  • 后来我又发现其实上面说取模运算快的,例子取余的数一直在变。也就是上面的i。 而求奇偶数中余上的数固定是2. 这里又研究看到了另二篇文章,才明白原因。 这里贴下结论 通过原理来计算取余和取模总结: fix 函数是...
  • java判断的时候,我们经常要用到取余的符号,那么,取余后用等于0和等于1判断真的没有关系吗? 有什么想法,就去实现!接下去,我们就用程序来试试~~ 等于1判断奇偶 等于0判断奇偶 那么,从结果可以看到,...
  • java取余操作的坑

    2021-11-14 23:31:55
    } 输出结果如下: time : 1636903381528 itime :1636903392879 time: 21636903392879 itime :21636903392879 a : 1409965409 可以看到运用了%运算,耗时慢了10秒 坑!!! 打比赛的小伙伴一定要慎用%运算 | 和 ...
  • 版权声明:转载请注明...取余运算和取模运算类似但是不同。同样的A%B,设C是A和B的商,即A=B*C。 C如果是整数,说明A和B整除,取余运算和取模运算都是0。 C如果是小数(绝大部分是这种情况),则看C是大于0还是...
  • java位运算常用操作

    2021-03-22 16:13:42
    java中常用的7个运算符:& 同为1则为1 否则为0| 一为1 则返回1~ 将操作数的每取反^ 两相同时返回0,不同时返回1<< 左移运算符 将操作数的二进制码整体左移指定位数,右边空出的以0填充 正数---乘2^...
  • 取余运算详解

    千次阅读 2021-12-03 09:47:38
    发现取余计算如果遇见负数,是很少遇见的情况,但是在实际编程过程中是很容易因为疏忽或者config中配置错误出现,负数取余的情况,所以要了解如此计算后会发生什么情况,加快刷题和debug速度 python和C/C++/JAVA在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,670
精华内容 9,868
关键字:

java取余位运算

java 订阅