Java的位运算符详解整理得比较全

合集下载

Java位运算知识点详解

Java位运算知识点详解

Java位运算知识点详解在⽇常的Java开发中,位运算使⽤的不多,使⽤的更多的是算数运算(+、-、*、/、%)、关系运算(<、>、<=、>=、==、!=)和逻辑运算(&&、||、!),所以相对来说对位运算不是那么熟悉,本⽂将以Java的位运算来详细介绍下位运算及其应⽤。

1、位运算起源位运算起源于C语⾔的低级操作,Java的设计初衷是嵌⼊到电视机顶盒内,所以这种低级操作⽅式被保留下来。

所谓的低级操作,是因为位运算的操作对象是⼆进制位,但是这种低级操作对计算机⽽⾔是⾮常简单直接,友好⾼效的。

在简单的低成本处理器上,通常位运算⽐除法快得多,⽐乘法快⼏倍,有时⽐加法快得多。

虽然由于较长的指令流⽔线和其他架构设计选择,现代处理器通常执⾏加法和乘法的速度与位运算⼀样快,但由于资源使⽤减少,位运算通常会使⽤较少的功率,所以在⼀些Java底层算法中,巧妙的使⽤位运算可以⼤量减少运⾏开销。

2、位运算详解Java位运算细化划分可以分为按位运算和移位运算,见下表。

细化符号描述运算规则按位运算&与两位都为1,那么结果为1 |或有⼀位为1,那么结果为1 ~⾮~0 = 1,~1 = 0^异或两位不相同,结果为1移位运算<< 左移各⼆进制位全部左移N位,⾼位丢弃,低位补0>> 右移各⼆进制位全部右移N位,若值为正,则在⾼位插⼊ 0,若值为负,则在⾼位插⼊ 1 >>> ⽆符号右移各⼆进制位全部右移N位,⽆论正负,都在⾼位插⼊0在进⾏位运算详解之前,先来普及下计算机中数字的表⽰⽅法。

对于计算机⽽⾔,万物皆0、1,所有的数字最终都会转换成0、1的表⽰,有3种体现形式,分别是:原码、反码和补码。

原码:原码表⽰法在数字前⾯增加了⼀位符号位,即最⾼位为符号位,正数位该位为0,负数位该位为1.⽐如⼗进制的5如果⽤8个⼆进制位来表⽰就是00000101,-5就是10000101。

Java中的位运算

Java中的位运算

Java中的位运算/*计算机由复杂电子元器件构成,一个电子元器件有带电和不带电的两种状态,1和0多个这样的元器件的组合可以表示更多状态,也就是可以表示更多的数据,一个元器件可以表示一位(bit)数据,这种表示数据的方式称为2进制在实际的电子设备中,将8个元器件组合在一起,形成一个单元,这样的单元叫做一个字节(byte)一个字节能表示2^8=256个数,即0-2552个字节能表示2^16个数,即0-2^16-14个字节能表示2^32个数,即0-2^32-1一个字节(byte)由8个二进位(bit)组成,最右边的称为最低有效位,最左边的称为最高有效位每一个二进位的值都是0或1*//*在计算机中常采用16位进制的方法,因为二进制书写太长,容易出错16进制的f代表十进制中的15,在二进制中需要4位(bit)1111来书写16进制中的ff代表十进制的255,在二进制中需要8位(bit)11111111来书写*///在计算机中只有数值,可以用数值表示不同的含义,如内存的数值可代表不同的含义//原码、反码和补码/*原码:将最高位作为符号位(1为负,0为正),其余各位代表数值本身的绝对值(二进制表示)以一个字节的数值为例:+7:00000111-7:10000111而问题在于:+0:00000000-0:10000000这样表示数值不唯一,因而在计算机中很少采用原码*//*反码:一个数如果为正,则它的反码和原码相同,如果为负,符号位为1,其余各位对原码取反如:+7的原码是:00000111+7的反码是:00000111-7的原码是:10000111-7的反码是:11111000问题还是:+0的反码是:00000000-0的反码是:11111111*//*补码:利用溢出,我们可以将减法变成加法//主要就是怎么操作、运算,使结果满足我们的需要对于十进制,如果要从9得到结果5,我们可以用减法:9-4=5因为4+6=10,我们将6作为4的补数,将上式的减法改成加法:9+6=15去掉高位1(也就是减去10),得到结果5对于16进制,如果从C得到结果5,我们可以用减法:C-7=5因为7+9=16,我们将9作为7的补数,将上式的减法改成加法:C+9=15(十进制中21)去掉高位1(也就是减去16),得到结果5*//*在计算机中,如果我们采用1个字节来表示一个数,则这个字节有8位(bit)超过8位(bit)就进1,在内存中情况为:1 00000000进位1被丢弃*//*补码:如果一个数如果为正,则它的原码、反码和补码相同如果一个数为负,则符号位为1,其余各位对原码取反,然后整个数加1为了简单起见,以一个字节来表示一个整数:+7的原码为:00000111+7的补码为:00000111-7的原码为:10000111-7的补码为:11111000//第一步取反+1//第二步加1----11111001//得到结果0的补码表示为:+0的补码为:00000000-0的补码为:10000000第一步取反:11111111第二步加1:100000000第三步进位1被丢弃,得到结果00000000与+0的表示相同*//*已知一个负数的补码,转换成十进制数,步骤为:1.先对各位取反2.将其转换成十进制数3.加上符号,再减去1例如:11111010,最高位是1,是负数,先对各位取反,变成00000101;转换成十进制数5,加上符号,变成-5,再减去1,变成-6*///位运算符(是对位(bit)进行运算,而不是对数值进行运算)/*Java中有4个位运算符:& 按位与| 按位或^ 按位异或~ 按位取反1.按位与01101101&00110111----00100101结论:按位与,只有壹(1)壹(1)与操作为12.按位或01101101|00110111----01111111结论:按位或,只有零(0)零(0)或操作为03.按位异或01101101^00110111----01011010结论:按位异或,只有零(0)壹(1)或者壹(1)零(0)异或操作为1 4.按位取反~ 01101101----10010010结论:按位取反,只要将1变成0,0变成1//Java中的移位运算符/*java中三个移位运算符:左移:<<带符号右移:>>无符号右移:>>>class count{public static void main(String[] argus) {int i1=-1;int i2=i1<<2;System.out.println(i1);System.out.println(i2);int i3=0xffffffff;int i4=i3<<2;System.out.println(i3);System.out.println(i4);}}。

Java 位运算符

Java 位运算符

Java 位运算符Java 定义的位运算(bitwise operators )直接对整数类型的位进行操作,这些整数类型包括long,int,short,char,and byte 。

表4-2 列出了位运算:表4.2 位运算符及其结果运算符结果~ 按位非(NOT)(一元运算)&amp; 按位与(AND)| 按位或(OR)^ 按位异或(XOR)&gt;&gt; 右移&gt;&gt;&gt; 右移,左边空出的位以0填充运算符结果&lt;&lt; 左移&amp;= 按位与赋值|= 按位或赋值^= 按位异或赋值&gt;&gt;= 右移赋值&gt;&gt;&gt;= 右移赋值,左边空出的位以0填充&lt;&lt;= 左移赋值续表既然位运算符在整数范围内对位操作,因此理解这样的操作会对一个值产生什么效果是重要的。

具体地说,知道Java 是如何存储整数值并且如何表示负数的是有用的。

因此,在继续讨论之前,让我们简短概述一下这两个话题。

所有的整数类型以二进制数字位的变化及其宽度来表示。

例如,byte 型值42的二进制代码是00101010 ,其中每个位置在此代表2的次方,在最右边的位以20开始。

向左下一个位置将是21,或2,依次向左是22,或4,然后是8,16,32等等,依此类推。

因此42在其位置1,3,5的值为1(从右边以0开始数);这样42是21+23+25的和,也即是2+8+32 。

所有的整数类型(除了char 类型之外)都是有符号的整数。

这意味着他们既能表示正数,又能表示负数。

Java 使用大家知道的2的补码(two&#8217;s complement )这种编码来表示负数,也就是通过将与其对应的正数的二进制代码取反(即将1变成0,将0变成1),然后对其结果加1。

例如,-42就是通过将42的二进制代码的各个位取反,即对00101010 取反得到11010101 ,然后再加1,得到11010110 ,即-42 。

Java位运算总结

Java位运算总结

Java位运算总结关于位运算,以前也见过,搜过,当时会⽤了,过后就忘了,今天好好学习⼀遍,然后整理⼀下。

Java中的位运算,涉及到计算机的⼆进制,位⽤bit表⽰,1Byte=8bit,根据各种基本数据类型占⽤的字节空间,可以计算各种数据有多少⼆进制,可以算出对应的取值范围。

java中的位运算包括:与(&)、或(|)、异或(^)和⾮(~); 移位运算包括:左移运算(<<)、右移运算(>>)和⽆符号右移运算(>>>),没有⽆符号左移运算。

前提:数字与数字位运算,都会先装换成⼆进制,下⾯不在重复,都默认转成⼆进制。

1、与(&)运算,两个数字与运算就是对⽐相同位的数字,都为1则为1,否则为0. 举例:3&4的值为多少? 3的⼆进制11,4的⼆进制100,没数字⽤0补齐,则是011对100,没有都为1的情况,则3&4的⼆进制结果为000,转换10进制也为0.2、或(|)运算,两个数字对⽐之后,有⼀个为1则为1。

举例:3|4的值为多少? 011对100,结果为111,转换为10进制为7。

3、异或(^)运算,对⽐之后,不同的为1,相同的为0。

举例:3^4的值为多少?011对100,结果为111,转换为10进制为7。

4、⾮(~)也叫取反运算,1变0,0变1。

具体的变化这⾥设涉及到,我单独写个帖⼦。

5、左移运算符(<<),将⼆进制的数据向左移动对应位数,低位⽤0补齐。

举例:3<<1,11变为110,转换为10进制变为6。

6、右移运算符(>>),将⼆进制的数据向右移动对应位数,如果是正数⾼位⽤0补齐,负数⾼位⽤1补齐。

举例:3>>1,11变为1,转换为10进制变为1。

-3>>1 为-2.7、⽆符号右移运算(>>>),将⼆进制的数据向右移动对应位数,⾼位全部⽤0补齐。

Java中的位运算符全解

Java中的位运算符全解

Java中的位运算符全解⽬录1. &(按位与运算符)2. |(按位或运算符)3. ^(异或运算符)4. <<(左移运算符)5. >> (右移移运算符)6. ~(取反运算符)7. >>>(⽆符号右移运算符)(1) 正数⽆符号右移(2) 负数⽆符号右移总结1. &(按位与运算符)&按位与的运算规则是将两边的数转换为⼆进制位,然后运算最终值,运算规则即(两个为真才为真):1&1=1 , 1&0=0 , 0&1=0 , 0&0=0public class Main {public static void main(String[] args) {// &按位与,运算符两边的条件值会先转换为2进制,然后再⽐对运算/*** 0 0 1 1* 0 1 0 1* -----------* 0 0 0 1*/int a = 3&5;/*** 0 0 0 1* 0 0 1 0* -----------* 0 0 0 0*/int b = 1&2;System.out.println(a);// 1System.out.println(b);// 0}}2. |(按位或运算符)|按位或和&按位与计算⽅式都是转换⼆进制再计算,不同的是运算规则(⼀个为真即为真):1|0 = 1 , 1|1 = 1 , 0|0 = 0 , 0|1 = 1public class Main {public static void main(String[] args) {// |按位或,运算符两边的条件值会先转换为2进制,然后再⽐对运算/*** 0 0 1 1* 0 1 0 1* -------------* 0 1 1 1*/int a = 3|5;/*** 0 0 0 1* 0 0 1 0* -------------* 0 0 1 1*/int b = 1|2;System.out.println(a);// 7System.out.println(b);// 3}}3. ^(异或运算符)^异或运算符顾名思义,异就是不同,其运算规则为1^0 = 1 , 1^1 = 0 , 0^1 = 1 , 0^0 = 0public class Main {public static void main(String[] args) {/*** 0 0 1 1* 0 1 0 1* -------------* 0 1 1 0*/int a = 3^5;/*** 0 0 0 1* 0 0 1 0* -------------* 0 0 1 1*/int b = 1^2;System.out.println(a);// 6System.out.println(b);// 3}}4. <<(左移运算符)5<<2的意思为5的⼆进制位往左挪两位,右边补05的⼆进制位是0000 0101,就是把有效值101往左挪两位就是0001 0100,正数左边第⼀位补0,负数补1,等于乘于2的n次⽅,⼗进制位是5*2^2=20public class Main {public static void main(String[] args) {/*** 5<<2的意思为5的⼆进制位往左挪两位,右边补0* 0 0 0 0 0 1 0 1* 0 0 0 1 0 1 0 0*/System.out.println(5<<2); // 20}}5. >> (右移移运算符)凡位运算符都是把值先转换成⼆进制再进⾏后续的处理5的⼆进制位是0000 0101,右移两位就是把101左移后为0000 0001,正数左边第⼀位补0,负数补1,等于除于2的n次⽅,结果为1public class Main {public static void main(String[] args) {/*** 5>>2的意思为5的⼆进制位往右挪两位,左边补0* 0 0 0 0 0 1 0 1* 0 0 0 0 0 0 0 1*/System.out.println(5<<2); // 1}}6. ~(取反运算符)取反就是1为0,0为15的⼆进制位是0000 0101,取反后为1111 1010,值为-6public class Main {public static void main(String[] args) {/*** 0 0 0 0 0 1 0 1* ---------------------* 1 1 1 1 1 0 1 0** 1、如果 11111010 想转为负的⼗进制,因为最⾼位是1,所以先将11111001减1得到11111001* 2、取反 00010101,然后计算出 00000100 对应的⼗进制为6* 3、所以 11111010 最终对应的⼗进制为 -6** 1 1 1 1 1 0 1 0* - 0 0 0 0 0 0 0 1* ---------------------* 1 1 1 1 1 0 0 1* ---------------------* 0 0 0 0 0 1 0 0*/System.out.println(~5); // -6}}7. >>>(⽆符号右移运算符)(1) 正数⽆符号右移⽆符号右移运算符和右移运算符的主要区别在于负数的计算,因为⽆符号右移是⾼位补0,移多少位补多少个0。

java-运算符总结

java-运算符总结

java-运算符总结java运算符总结Java运算符共包括这⼏种:算术运算符、⽐较运算符、位运算符、逻辑运算符、赋值运算符和其他运算符。

(该图来⾃⽹络)简单的运算符,就不过多介绍使⽤了,可⾃⾏测试。

关于赋值运算,可以结合算术运算和位运算来简化代码。

int a = 5;a += a; // a = a + a;a /= a; // a = a / a;a %= a; // a = a % a;a &= 6; // a = a & 6;//.....理解⾃增⾃减运算符⾃增⾃减分为前置和后置。

例如:i++++i i----i。

要明确⼀点,前置与后置的⾃增或⾃减运算符若没运⽤到表达式中,那么⽆区别;若是参与到表达式运算中,只需记住:谁在前⾯就先执⾏谁.int a = 0;a++; //或者++aSystem.out.println(a); // a输出1 //最常见的for循环中,在迭代条件中,i++ 和 ++i⽆区别,因为没有⽤于表达式。

将前置⾃增和后置⾃增运⽤到表达式int a = 5;System.out.println(a--); //5,先打印a的值,之后a⾃减1System.out.println(a); //4System.out.println(++a); //5, 先对a值⾃增,然后打印a值复杂⼀点,更好的理解前置和后置的区别:int a = 6;int b = 8;int c = ++a + b-- - a-- + --b + b++ + --a;System.out.printf("%d|%d|%d", a,b,c); // 5,7,25使⽤图⽚来理解会更加⼀⽬了然。

再随便给⼀个,按照图⽰⽅式去理解⾃增⾃减。

int a = 6,b = 8;int c = (--a) + (a--) - (b--) + (++b) + (a++) - (b--); //加括号更容易阅读// int c = --a + a-- - b-- + ++b + a++ - b--;System.out.printf("%d|%d|%d", a,b,c); // 5,7,6}通过图⽚的理解⽅式去学习⾃增⾃减,⽆论是前置还是后置,⽆论会有多复杂,都可以很有条理的解决。

java左移和右移的运算规则

java左移和右移的运算规则

java左移和右移的运算规则在Java中,左移和右移是位运算符,用于将一个数的二进制位向左或向右移动特定的位数。

运算结果是将数值的二进制位进行移动,移动后的空位用0或符号位进行填充。

下面是关于Java中左移和右移运算的规则的详细解释。

1.左移运算符(<<):左移的规则如下:-对于左移n位的操作,将原始数值转换为二进制形式。

-向左移动n位,并在右侧用0进行填充。

- 如果左移的位数超过了数据类型的位数(例如,对于int类型的数据,左移的位数超过了32位),则左移的结果是未定义的。

左移运算符的示例代码:```javaSystem.out.println(result);```输出:```20```2.右移运算符(>>):右移运算符将一个数的二进制位向右移动指定的位数。

每个位的值向右移动并丢弃右侧的位,左侧使用符号位进行填充。

如果原始数是正数,则右移的结果和除以2的n次幂相同。

如果原始数是负数,则右移的结果不同于除以2的n次幂。

右移的规则如下:-对于右移n位的操作,将原始数值转换为二进制形式。

-向右移动n位,并在左侧用符号位进行填充。

-如果原始数是正数,则右移的结果和除以2的n次幂相同。

-如果原始数是负数,则右移的结果不同于除以2的n次幂,因为使用符号位进行填充。

右移运算符的示例代码:```javaSystem.out.println(result);```输出:``````无符号右移运算符将一个数的二进制位向右移动指定的位数,丢弃右侧位并使用0进行填充。

无符号右移运算符不管原始数的符号,始终在左侧使用0填充。

无符号右移的规则如下:-对于无符号右移n位的操作,将原始数值转换为二进制形式。

-向右移动n位,并在左侧用0进行填充。

-无符号右移操作不管原始数的符号,始终在左侧使用0进行填充。

无符号右移运算符的示例代码:```javaSystem.out.println(result);```输出:```29```左移和右移运算是Java中非常有用的位运算符,可以进行高效的位操作和数值计算。

java位运算技巧

java位运算技巧

java位运算技巧位运算是计算机中常用的一种运算方式,它以二进制的形式进行操作,能够快速地进行一些特定的计算。

在Java中,也提供了一些位运算的操作符和方法,可以帮助我们更加高效地进行一些位运算操作。

下面将介绍一些Java中的位运算技巧。

1.位运算符Java提供了六个位运算符,包括按位与(&)、按位或(,)、按位异或(^)、按位取反(~)、左移位(<<)和右移位(>>)。

这些运算符可以直接应用于整型数据,进行相应的位运算操作。

2.利用位运算进行快速乘、除、取余利用位运算,可以实现快速的乘法、除法和取余运算。

例如,可以使用左移位(<<)实现乘法,右移位(>>)实现除法,按位与(&)实现取余。

这些方法通常比使用乘法、除法和取余运算符更加高效。

3.判断奇偶性使用位运算符与1相与(&),可以判断一个整数的奇偶性。

如果结果为1,则表示该数为奇数;如果结果为0,则表示该数为偶数。

这是因为二进制中,末位为1表示奇数,末位为0表示偶数。

4.交换两个数字使用异或(^)操作可以交换两个变量的值。

例如,要交换变量a和b的值,可以使用以下代码:a=a^b;b=a^b;a=a^b;这样就可以实现交换a和b的值,而不需要使用第三个变量。

5.判断两个数是否相等使用位异或(^)可以判断两个数是否相等。

如果两个数相等,则异或结果为0;如果两个数不等,则异或结果不为0。

可以利用这个特性,来判断两个数是否相等。

6.利用位运算判断是否为2的幂次方如果一个数位2的幂次方,则它的二进制表示中只有一位为1,其余位都为0。

根据这个特性,可以使用位运算来判断一个数是否是2的幂次方。

可以使用按位与(&)和减一(-1)操作,如果结果为0,则表示该数是2的幂次方。

7.判断指定位是否为1可以使用右移位(>>)和按位与(&)操作,来判断一个整数的指定位是否为1、例如,要判断整数num从右边开始的第n位是否为1,可以使用以下代码:if ((num >> n) & 1 == 1)//第n位为1} else//第n位为0其中,num >> n操作将num右移n位,然后与1按位与,如果结果为1,则表示第n位为1;如果结果为0,则表示第n位为0。

java中的位运算符和运算符优先级

java中的位运算符和运算符优先级

java中的位运算符和运算符优先级1 位运算符一共3个移位运算符,左移位<<,右移位>>和无符号移位>>>。

左移位<<在低位处补0。

右移位>>若值为正则在高位插入0,若值为负则在高位插入1。

无符号右移位>>>无论正负都在高位处插入0。

非运算符~ &(与运算)对1 位运算符一共3个移位运算符,左移位<<,右移位>>和无符号移位>>>。

左移位<<在低位处补0。

右移位>>若值为正则在高位插入0,若值为负则在高位插入1。

无符号右移位>>>无论正负都在高位处插入0。

非运算符~&(与运算)对两个整型操作数中对应位执行布尔代数,两个位都为1时输出1,否则0。

^(异或运算先做或运算再做运算)对两个整型操作数中对应位执行布尔代数,两个位相等0,不等1。

|(或运算)对两个整型操作数中对应位执行布尔代数,两个位都为0时输出0,否则1。

如:以下哪种运算正确:A. 1010 0000 0000 0000 0000 0000 0000 0000 >> 4gives 0000 1010 0000 0000 0000 0000 0000 0000B. 1010 0000 0000 0000 0000 0000 0000 0000 >> 4gives 1111 1010 0000 0000 0000 0000 0000 0000C. 1010 0000 0000 0000 0000 0000 0000 0000 >>> 4gives 0000 1010 0000 0000 0000 0000 0000 0000D. 1010 0000 0000 0000 0000 0000 0000 0000 >>> 4gives 1111 1010 0000 0000 0000 0000 0000 0000选:B C以下哪一运算正确:A. 0000 0100 0000 0000 0000 0000 0000 0000 << 5gives 1000 0000 0000 0000 0000 0000 0000 0000B. 0000 0100 0000 0000 0000 0000 0000 0000 << 5gives 1111 1100 0000 0000 0000 0000 0000 0000C. 1100 0000 0000 0000 0000 0000 0000 0000 >> 5gives 1111 1110 0000 0000 0000 0000 0000 0000D. 1100 0000 0000 0000 0000 0000 0000 0000 >> 5gives 0000 0110 0000 0000 0000 0000 0000 0000选:A CGiven:1.Public class test (2. Public static void main (String args[]) (3. System.out.printIn (6 ^ 3);4. )5.)What is the outputAns: 52 位运算符返回的是数值,不是boolean类型值如:if(5&7>0 && 5|2)System.out.println("true");显示:编译出错3 对于一个整型数进行移位,其右操作数应该小于32,对于一个长整型数进行移位,其右操作数应该小于64。

java的位运算符详解实例

java的位运算符详解实例

与(&)、非(~)、或(|)、异或(^)位运算符主要针对二进制,它包括了:“与”、“非”、“或”、“异或”。

从表面上看似乎有点像逻辑运算符,但逻辑运算符是针对两个关系运算符来进行逻辑运算,而位运算符主要针对两个二进制数的位进行逻辑运算。

下面详细介绍每个位运算符。

1.与运算符与运算符用符号“&”表示,其使用规律如下:两个操作数中位都为1,结果才为1,否则结果为0,例如下面的程序段。

public class data13{public static void main(String[] args){int a=129;int b=128;System.out.println("a 和b 与的结果是:"+(a&b));}}运行结果a 和b 与的结果是:128下面分析这个程序:“a”的值是129,转换成二进制就是10000001,而“b”的值是128,转换成二进制就是10000000。

根据与运算符的运算规律,只有两个位都是1,结果才是1,可以知道结果就是10000000,即128。

2.或运算符或运算符用符号“|”表示,其运算规律如下:两个位只要有一个为1,那么结果就是1,否则就为0,下面看一个简单的例子。

public class data14{public static void main(String[] args){int a=129;int b=128;System.out.println("a 和b 或的结果是:"+(a|b));}}运行结果a 和b 或的结果是:129下面分析这个程序段:a 的值是129,转换成二进制就是10000001,而b 的值是128,转换成二进制就是10000000,根据或运算符的运算规律,只有两个位有一个是1,结果才是1,可以知道结果就是10000001,即129。

3.非运算符非运算符用符号“~”表示,其运算规律如下:如果位为0,结果是1,如果位为1,结果是0,下面看一个简单例子。

java运算符知识点

java运算符知识点

java运算符知识点Java运算符知识点。

一、算术运算符。

1. 基本算术运算符。

- 加法(+)- 用于计算两个操作数的和。

例如:`int a = 3; int b = 5; int sum = a + b;`,这里`sum`的值为8。

- 在Java中,也可用于字符串连接。

如果操作数中有一个是字符串,另一个操作数将被转换为字符串并连接起来。

例如:`String s1 = "Hello"; int num = 10; String result = s1+num;`,此时`result`的值为`Hello10`。

- 减法(-)- 计算两个操作数的差。

如`int x = 10; int y = 3; int diff = x - y;`,`diff`的值为7。

- 乘法(*)- 求两个操作数的乘积。

例如:`int m = 4; int n = 6; int product = m * n;`,`product`的值为24。

- 除法(/)- 当操作数都是整数类型时,执行整数除法,结果为商的整数部分。

例如:`int dividend = 10; int divisor = 3; int quotient = dividend / divisor;`,`quotient`的值为3。

- 如果操作数中有一个是浮点数类型,则执行浮点数除法,得到精确的商。

例如:`double num1 = 10.0; int num2 = 3; double result = num1 / num2;`,`result`的值为3.333333...- 取余(%)- 计算两个操作数相除的余数。

例如:`int num3 = 10; int num4 = 3; int remainder = num3 % num4;`,`remainder`的值为1。

2. 自增(++)和自减(--)运算符。

- 自增(++)- 有前置和后置两种形式。

java位运算符详解

java位运算符详解

java位运算符详解java 位运算符⼀、概述Java 定义的位运算(bitwise operators)直接对整数类型的位进⾏操作,这些整数类型包括 long,int,short,char 和 byte。

位运算符主要⽤来对操作数⼆进制的位进⾏运算。

按位运算表⽰按每个⼆进制位(bit)进⾏计算,其操作数和运算结果都是整型值。

Java 语⾔中的位运算符分为位逻辑运算符和位移运算符两类,下⾯详细介绍每类包含的运算符。

⼆、位逻辑运算符位逻辑运算符包含 4 个:&(与)、|(或)、~(⾮)和 ^(异或)。

除了 ~(即位取反)为单⽬运算符外,其余都为双⽬运算符。

表 1 中列出了它们的基本⽤法。

运算符含义实例结果&按位进⾏与运算(AND) 4 & 54|按位进⾏或运算(OR) 4 | 55^按位进⾏异或运算(XOR)4 ^ 51~按位进⾏取反运算(NOT)~ 4-52.1 位与运算符: &运算规则:参与运算的数字,低位对齐,⾼位不⾜的补零,如果对应的⼆进制位同时为 1,那么计算结果才为 1,否则为 0。

因此,任何数与 0 进⾏按位与运算,其结果都为 0。

以 100 & 0 为例:System.out.print("位与运算: " + "整型");System.out.println( 0&100);System.out.println("整型转为⼆进制:" + Integer.toBinaryString(0&100) );运⾏结果:位与运算:整型:0整型转为⼆进制:02.2 位或运算符: |运算规则:参与运算的数字,低位对齐,⾼位不⾜的补零。

如果对应的⼆进制位只要有⼀个为 1,那么结果就为 1;如果对应的⼆进制位都为 0,结果才为 0。

下⾯以11 | 7 为例:System.out.print("位或运算: " + "整型");System.out.println( 11|7 );System.out.println("整型转为⼆进制:" + Integer.toBinaryString(11|7) );运⾏结果:位或运算:整型:15整型转为⼆进制:11112.3 位异或运算符: ^运算规则:参与运算的数字,低位对齐,⾼位不⾜的补零,如果对应的⼆进制位相同(同时为 0 或同时为 1)时,结果为 0;如果对应的⼆进制位不相同,结果则为 1。

Java的位运算符详解整理得比较全

Java的位运算符详解整理得比较全

Java的位运算符详解实例——与(&)、非(~)、或(|)、异或(^)位运算符主要针对二进制,它包括了:“与”、“非”、“或”、“异或”。

从表面上看似乎有点像逻辑运算符,但逻辑运算符是针对两个关系运算符来进行逻辑运算,而位运算符主要针对两个二进制数的位进行逻辑运算。

下面详细介绍每个位运算符。

1.与运算符与运算符用符号“&”表示,其使用规律如下:两个操作数中位都为1,结果才为1,否则结果为0,例如下面的程序段。

public class data13{public static void main(String[] args){int a=129;int b=128;System.out.println("a 和b 与的结果是:"+(a&b));}}运行结果a 和b 与的结果是:128下面分析这个程序:“a”的值是129,转换成二进制就是10000001,而“b”的值是128,转换成二进制就是10000000。

根据与运算符的运算规律,只有两个位都是1,结果才是1,可以知道结果就是10000000,即128。

2.或运算符或运算符用符号“|”表示,其运算规律如下:两个位只要有一个为1,那么结果就是1,否则就为0,下面看一个简单的例子。

public class data14{public static void main(String[] args){int a=129;int b=128;System.out.println("a 和b 或的结果是:"+(a|b));}}运行结果a 和b 或的结果是:129下面分析这个程序段:a 的值是129,转换成二进制就是10000001,而b 的值是128,转换成二进制就是10000000,根据或运算符的运算规律,只有两个位有一个是1,结果才是1,可以知道结果就是10000001,即129。

3.非运算符非运算符用符号“~”表示,其运算规律如下:如果位为0,结果是1,如果位为1,结果是0,下面看一个简单例子。

java中的位运算符

java中的位运算符

java中的位运算符Java中常⽤的位运算符1.按位与 &2.按位或 |3.按位异或 ^4.按位取反 ~5.左移 <<6.带符号右移 >>7.⽆符号右移 >>>位运算符的含义位运算符都是基于⼆进制进⾏计算的,且位运算符都是针对与int类型进⾏操作1.按位与 int a=1&1=1; int b=1&2=0;2.按位或 int a=1|1=1; int b=1|2=3;3.按位异或异或的概念为若两个相同则返回false,两个不同则返回true,在位运算符中相同返回0,不同返回1int a=1^1=0; int b=1^2=3;4.按位取反 int a=~1=-2 int b=~2=-3应为在计算机中是⽤补码表⽰数字的,所以按位取反后的数字是⼀个补码,因此需将补码换为原码才是这个数的值例:1=(00000001)(按位取反)=11111110(补码)=(反码)10000001=(反码+1)=10000010(原码)=-2补码的补码是补码的原码5.左移 int a=1<<2=4 int b=2<<2=86.带符号右移 >> 表⽰右移,如果该数为正,则⾼位补0,若为负数,则⾼位补1。

例如:int a=8>>2=00001000>>2=00000010=2int -8>>2=1111_1111 1111_1111 1111_1111 1111_1000(补码)>>2=1111_1111 1111_1111 1111_1111 1111_1110(补码)=1000_0000 0000_0000 0000_0000 0000_0010(原码)=-27.⽆符号右移 >>>表⽰⽆符号右移,也叫逻辑右移,即若该数为正,则⾼位补0,⽽若该数为负数,则右移后⾼位同样补0例如:int a=8>>>2=2int -8>>>2=1111_1111 1111_1111 1111_1111 1111_1000(补码)>>>2=0011_1111 1111_1111 1111_1111 1111_1110(补码)=0011_1111 1111_1111 1111_1111 1111_1110(原码)=1073741822。

Java位运算(移位、位与、或、异或、非)

Java位运算(移位、位与、或、异或、非)

提供地位运算符有:左移( << )、右移( >> ) 、无符号右移( >>> ) 、位与( ) 、位或( )、位非( )、位异或( ^ ),除了位非( )是一元操作符外,其它地都是二元操作符.、左移( << )、将左移位:[];{([] ) {(<<)运行结果是}}运行结果是,但是程序是怎样执行地呢?首先会将转为进制表示形式(中,整数默认就是类型,也就是位):然后左移位后,低位补:换算成进制为、右移( >> ) ,右移同理,只是方向不一样罢了(感觉和没说一样)[](>>)运行结果是还是先将转为进制表示形式:然后右移位,高位补:、无符号右移( >>> )我们知道在中类型占位,可以表示一个正数,也可以表示一个负数.正数换算成二进制后地最高位为,负数地二进制最高为为例如换算成二进制后为:(刚开始接触二进制时,不知道最高位是用来表示正负之分地,当时就总想不通..明明算起来得到地就是一个正数)我们分别对进行右移位、进行右移位和无符号右移位:[];{([] ) {(>>)结果是(>>)结果是(>>>)结果是}}我们来看看它地移位过程(可以通过其结果换算成二进制进行对比):换算成二进制:右移位后结果为,地二进制为:(用进行补位)换算成二进制:右移位后结果为,地二进制为:(用进行补位)无符号右移位后地结果换算成二进制:(用进行补位)通过其结果转换成二进制后,我们可以发现,正数右移,高位用补,负数右移,高位用补,当负数使用无符号右移时,用进行部位(自然而然地,就由负数变成了正数了)注意:笔者在这里说地是右移,高位补位地情况.正数或者负数左移,低位都是用补.(自行测试)、位与( )[];{([] ) {( )结果为}}还是老套路,将个操作数和结果都转换为二进制进行比较:转换为二进制:转换为二进制:转换为二进制:位与:第一个操作数地地第位于第二个操作数地第位如果都是,那么结果地第为也为,否则为、位或( )[];{([] ) {( )结果为}}转换为二进制:转换为二进制:转换为二进制:位或操作:第一个操作数地地第位于第二个操作数地第位只要有一个是,那么结果地第为也为,否则为、位异或( ^ )[];{([] ) {( ^ )结果为}}转换为二进制:转换为二进制:转换为二进制:位异或:第一个操作数地地第位于第二个操作数地第位相反,那么结果地第为也为,否则为、位非( ) 位非是一元操作符[];{([] ) {()结果为}}转换为二进制:转换为二进制:位非:操作数地第位为,那么结果地第位为,反之.由位运算操作符衍生而来地有:按位与赋值按位或赋值^ 按位非赋值>> 右移赋值>>> 无符号右移赋值<< 赋值左移和一个概念而已.举个例子:[];{([] ) {;()结果是}}。

Java中的位运算

Java中的位运算

Java中的位运算位运算是计算机中一种特殊的运算方式,它直接对二进制数进行操作。

在Java中,位运算提供了一种高效且灵活的处理二进制数据的方式。

本文将介绍Java中的位运算符及其使用方法,以及位运算在程序开发中的常见应用场景。

一、按位与运算(&)按位与运算符(&)用来判断两个二进制数的对应位是否同时为1,如果是,则结果为1;否则结果为0。

在Java中,按位与运算可以用于掩码操作、判断某个特定位置上的位是否为1等情况。

示例代码:```javaint a = 5; // 二进制表示为 00000101int b = 3; // 二进制表示为 00000011int result = a & b; // 位运算结果为 00000001,即1System.out.println(result);```二、按位或运算(|)按位或运算符(|)用来判断两个二进制数的对应位是否有一个为1,如果是,则结果为1;否则结果为0。

在Java中,按位或运算可以用于将某些特定位设置为1、进行权限控制等情况。

示例代码:```javaint a = 5; // 二进制表示为 00000101int b = 3; // 二进制表示为 00000011int result = a | b; // 位运算结果为 00000111,即7System.out.println(result);```三、按位异或运算(^)按位异或运算符(^)用来判断两个二进制数的对应位是否不相同,如果不相同,则结果为1;否则结果为0。

在Java中,按位异或运算可以用于进行数字的交换、检测奇偶性等情况。

示例代码:```javaint a = 5; // 二进制表示为 00000101int b = 3; // 二进制表示为 00000011int result = a ^ b; // 位运算结果为 00000110,即6System.out.println(result);```四、按位取反运算(~)按位取反运算符(~)用来对一个二进制数进行按位取反操作,即将0变为1,1变为0。

java位运算

java位运算

java位运算Java 位运算符位运算符⽤来对⼆进制位进⾏操作 ,Java中提供了如下所⽰的位运算符 :位运算符 (>>,<<,>>>,&,|,^,~ ) ,位运算符中 ,除~以外 ,其余均为⼆元运算符。

操作数只能为整型和字符型数据。

⼗进制和⼆进制互转算法⼗进制转⼆进制:⽤2辗转相除⾄结果为1将余数和最后的1从下向上倒序写就是结果例如302302/2 = 151 余0151/2 = 75 余175/2 = 37 余137/2 = 18 余118/2 = 9 余09/2 = 4 余14/2 = 2 余02/2 = 1 余0故⼆进制为100101110⼆进制转⼗进制从最后⼀位开始算,依次列为第0、1、2...位第n位的数(0或1)乘以2的n次⽅得到的结果相加就是答案例如:01101011.转⼗进制:第0位:1乘2的0次⽅=11乘2的1次⽅=20乘2的2次⽅=01乘2的3次⽅=80乘2的4次⽅=01乘2的5次⽅=321乘2的6次⽅=640乘2的7次⽅=0然后:1+2+0+8+0+32+64+0=107.⼆进制01101011=⼗进制107.o补码所有的整数类型(除了char 类型之外)都是有符号的整数。

这意味着他们既能表⽰正数,⼜能表⽰负数。

Java使⽤补码来表⽰⼆进制数 ,在补码表⽰中 ,最⾼位为符号位 ,正数的符号位为 0,负数为 1。

补码的规定如下 :对正数来说 ,最⾼位为 0,其余各位代表数值本⾝ (以⼆进制表⽰ ),如 +42的补码为 00101010。

对负数⽽⾔ ,把该数绝对值的补码按位取反 ,然后对整个数加 1,即得该数的补码。

如 -42的补码为 11010110 (00101010 按位取反 11010101 +1=11010110 )⽤补码来表⽰数 ,0的补码是唯⼀的 ,都为 00000000。

(⽽在原码 ,反码表⽰中 ,+0和 -0的表⽰是不唯⼀的 ,可参见相应的书籍)。

Java位运算符详解

Java位运算符详解

位运算符位运算是以二进制位为单位进行的运算,其操作数和运算结果都是整型值。

位运算符共有7个,分别是:位与(&)、位或(|)、位非(~)、位异或(^)、右移(>>)、左移(<<)、0填充的右移(>>>)。

位运算的位与(&)、位或(|)、位非(~)、位异或(^)与逻辑运算的相应操作的真值表完全相同,其差别只是位运算操作的操作数和运算结果都是二进制整数,而逻辑运算相应操作的操作数和运算结果都是逻辑值。

位运算示例运算符名称示例说明& 位与x&y 把x和y按位求与交集| 位或x|y 把x和y按位求或并集~ 位非~x 把x按位求非^ 位异或x^y 把x和y按位求异或>> 右移x>>y 把x的各位右移y位<< 左移x<<y 把x的各位左移y位>>> 右移x>>>y 把x的各位右移y位,左边填0举例说明:(1)有如下程序段:int x = 64; //x等于二进制数的01000000int y = 70; //y等于二进制数的01000110int z = x&y //z等于二进制数的01000000即运算结果为z等于二进制数01000000。

位或、位非、位异或的运算方法类同。

(2)右移是将一个二进制数按指定移动的位数向右移位,移掉的被丢弃,左边移进的部分或者补0(当该数为正时),或者补1(当该数为负时)。

这是因为整数在机器内部采用补码表示法,正数的符号位为0,负数的符号位为1。

例如,对于如下程序段:int x = 70; //x等于二进制数的1000110int y = 2; //y等于二进制数的0000001int z = x>>y //z等于二进制数的0010001即运算结果为z等于二进制数00010001,即z等于十进制数17。

java中的位运算

java中的位运算

JAVA的位运算关键字: java 位运算Java 位运算一,Java 位运算1.表示方法:在Java语言中,二进制数使用补码表示,最高位为符号位,正数的符号位为0,负数为1。

补码的表示需要满足如下要求。

(l)正数的最高位为0,其余各位代表数值本身(二进制数)。

(2)对于负数,通过对该数绝对值的补码按位取反,再对整个数加1。

2.位运算符位运算表达式由操作数和位运算符组成,实现对整数类型的二进制数进行位运算。

位运算符可以分为逻辑运算符(包括~、&、|和^)及移位运算符(包括>>、<<和>>>)。

注释:~~是取反运算首先,你要知道java中的int是32位的其次,正数以原码的形式存储,负数以补码的形式存储4的二进制是0000 0000 0000 0000 0000 0000 0000 0100取反后得1111 1111 1111 1111 1111 1111 1111 1011java中都是有符号数,首位是1,所以是负数,负数也就是补码,也就是说1111 1111 1111 1111 1111 1111 1111 1011是补码补码,反码加1后得源码转换成源码得0000 0000 0000 0000 0000 0000 0000 0101这个数是5,加上符号就是-51)左移位运算符(<<)能将运算符左边的运算对象向左移动运算符右侧指定的位数(在低位补0)。

2)“有符号”右移位运算符(>>)则将运算符左边的运算对象向右移动运算符右侧指定的位数。

“有符号”右移位运算符使用了“符号扩展”:若值为正,则在高位插入0;若值为负,则在高位插入1。

3)Java也添加了一种“无符号”右移位运算符(>>>),它使用了“零扩展”:无论正负,都在高位插入0。

这一运算符是C或C++没有的。

4)若对char,byte或者short进行移位处理,那么在移位进行之前,它们会自动转换成一个int。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

Java的位运算符详解实例——与(&)、非(~)、或(|)、异或(^)位运算符主要针对二进制,它包括了:“与”、“非”、“或”、“异或”。

从表面上看似乎有点像逻辑运算符,但逻辑运算符是针对两个关系运算符来进行逻辑运算,而位运算符主要针对两个二进制数的位进行逻辑运算。

下面详细介绍每个位运算符。

1.与运算符与运算符用符号“&”表示,其使用规律如下:两个操作数中位都为1,结果才为1,否则结果为0,例如下面的程序段。

public class data13{public static void main(String[] args){int a=129;int b=128;System.out.println("a 和b 与的结果是:"+(a&b));}}运行结果a 和b 与的结果是:128下面分析这个程序:“a”的值是129,转换成二进制就是10000001,而“b”的值是128,转换成二进制就是10000000。

根据与运算符的运算规律,只有两个位都是1,结果才是1,可以知道结果就是10000000,即128。

2.或运算符或运算符用符号“|”表示,其运算规律如下:两个位只要有一个为1,那么结果就是1,否则就为0,下面看一个简单的例子。

public class data14{public static void main(String[] args){int a=129;int b=128;System.out.println("a 和b 或的结果是:"+(a|b));}}运行结果a 和b 或的结果是:129下面分析这个程序段:a 的值是129,转换成二进制就是10000001,而b 的值是128,转换成二进制就是10000000,根据或运算符的运算规律,只有两个位有一个是1,结果才是1,可以知道结果就是10000001,即129。

3.非运算符非运算符用符号“~”表示,其运算规律如下:如果位为0,结果是1,如果位为1,结果是0,下面看一个简单例子。

public class data15{public static void main(String[] args){int a=2;System.out.println("a 非的结果是:"+(~a));}}4.异或运算符异或运算符是用符号“^”表示的,其运算规律是:两个操作数的位中,相同则结果为0,不同则结果为1。

下面看一个简单的例子。

public class data16{public static void main(String[] args){int a=15;int b=2;System.out.println("a 与b 异或的结果是:"+(a^b));}}运行结果a 与b 异或的结果是:13分析上面的程序段:a 的值是15,转换成二进制为1111,而b 的值是2,转换成二进制为0010,根据异或的运算规律,可以得出其结果为1101 即13。

Java中的运算符(操作符)程序的基本功能是处理数据,任何编程语言都有自己的运算符。

因为有了运算符,程序员才写出表达式,实现各种运算操作,实现各种逻辑要求。

为实现逻辑和运算要求,编程语言设置了各种不同的运算符,且有优先级顺序,所以有的初学者使用复杂表达式的时候搞不清楚。

这里详细介绍一下Java中的运算符。

Java运算符很多,下面按优先顺序列出了各种运算符。

一、一元运算符因操作数是一个,故称为一元运算符。

++x 因为++在前,所以先加后用。

x++ 因为++在后,所以先用后加。

注意:a+ ++b和a+++b是不一样的(因为有一个空格)。

int a=10;int b=10;int sum=a+ ++b;System.out.println("a="+a+",b="+b+",sum="+sum);运行结果是:a=10,b=11,sum=21int a=10;int b=10;int sum=a+++b;System.out.println("a="+a+",b="+b+",sum="+sum);运行结果是:a=11,b=10,sum=20n=10;m=~n;变量n的二进制数形式:00000000 00000000 00000000 00001010逐位取反后,等于十进制的-11: 11111111 11111111 11111111 11110101二、算术运算符所谓算术运算符,就是数学中的加、减、乘、除等运算。

因算术运算符是运算两个操作符,故又称为二元运算符。

这些操作可以对不同类型的数字进行混合运算,为了保证操作的精度,系统在运算过程中会做相应的转化。

数字精度的问题,我们在这里不再讨论。

下图中展示了运算过程中,数据自动向上造型的原则。

注:1、实线箭头表示没有信息丢失的转换,也就是安全性的转换,虚线的箭头表示有精度损失的转化,也就是不安全的。

2、当两个操作数类型不相同时,操作数在运算前会子松向上造型成相同的类型,再进行运算。

示例如下:[java]view plaincopy1. int a=22;2. int b=5;3. double c=5;4.5. System.out.println(b+"+"+c+"="+(b+c));6. System.out.println(b+"-"+c+"="+(b-c));7. System.out.println(b+"*"+c+"="+(b*c));8. System.out.println(a+"/"+b+"="+(a/b));9. System.out.println(a+"%"+b+"="+(a%b));10. System.out.println(a+"/"+c+"="+(a/c));11. System.out.println(a+"%"+c+"="+(a%c));运行结果如下:5+5.0=10.05-5.0=0.05*5.0=25.022/5=422%5=222/5.0=4.422%5.0=2.0三、移位运算符移位运算符操作的对象就是二进制的位,可以单独用移位运算符来处理int型整数。

以int类型的6297为例,代码如下:[java]view plaincopy1. System.out.println(Integer.toBinaryString(6297));2. System.out.println(Integer.toBinaryString(-6297));3. System.out.println(Integer.toBinaryString(6297>>5));4. System.out.println(Integer.toBinaryString(-6297>>5));5. System.out.println(Integer.toBinaryString(6297>>>5));6. System.out.println(Integer.toBinaryString(-6297>>>5));7. System.out.println(Integer.toBinaryString(6297<<5));8. System.out.println(Integer.toBinaryString(-6297<<5));运行结果:1100010011001 1111111111111111111001110110011111000100111111111111111111111111001110111100010011111111111111111110011101111000100110010000011111111111111001110110011100000注:x<<y 相当于x*2y ;x>>y相当于x/2y从计算速度上讲,移位运算要比算术运算快。

如果x是负数,那么x>>>3没有什么算术意义,只有逻辑意义。

四、关系运算符Java具有完备的关系运算符,这些关系运算符同数学中的关系运算符是一致的。

具体说明如下:instanceof操作符用于判断一个引用类型所引用的对象是否是一个类的实例。

操作符左边的操作元是一个引用类型,右边的操作元是一个类名或者接口,形式如下:obj instanceof ClassName 或者obj instanceof InterfaceName关系运算符产生的结果都是布尔型的值,一般情况下,在逻辑与控制中会经常使用关系运算符,用于选择控制的分支,实现逻辑要求。

需要注意的是:关系运算符中的"=="和"!="既可以操作基本数据类型,也可以操作引用数据类型。

操作引用数据类型时,比较的是引用的内存地址。

所以在比较非基本数据类型时,应该使用equals方法。

五、逻辑运算符在运用逻辑运算符进行相关的操作,就不得不说“短路”现象。

代码如下:if(1==1 && 1==2 && 1==3){ }代码从左至右执行,执行第一个逻辑表达式后:true && 1==2 && 1==3执行第二个逻辑表达式后:true && false && 1==3因为其中有一个表达式的值是false,可以判定整个表达式的值是false,就没有必要执行第三个表达式了,所以java虚拟机不执行1==3代码,就好像被短路掉了。

逻辑或也存在“短路”现象,当执行到有一个表达式的值为true时,整个表达式的值就为true,后面的代码就不执行了。

“短路”现象在多重判断和逻辑处理中非常有用。

我们经常这样使用:[java]view plaincopy1. public void a(String str){2. if(str!=null && str.trim().length()>0){3.4. }5. }如果str为null,那么执行str.trim().length()就会报错,短路现象保证了我们的代码能够正确执行。

相关文档
最新文档