java逻辑运算符有哪些,JAVA中&&和 是什么意思？怎么用

java逻辑运算符有哪些,JAVA中&&和 是什么意思？怎么用详细介绍

本文目录一览： java逻辑运算符都有哪些

逻辑运算符包括 &&、||、！。其中 && 和 || 是双目运算符，实现逻辑与、逻辑或；！是单目运算符，实现逻辑非。
结果为 boolean 型的变量或表达式可以通过逻辑运算符结合成为逻辑表达式。逻辑运算符 &&、|| 和 ！按表 2 进行逻辑运算。
逻辑运算符的优先级为：！运算级别最高，&& 运算高于 || 运算。！运算符的优先级高于算术运算符，而 && 和 || 运算则低于关系运算符。结合方向是：逻辑非（单目运算符）具有右结合性，逻辑与和逻辑或（双目运算符）具有左结合性。
扩展资料：
逻辑运算符的示例。
x>0 && x<=100 //第一行语句
y%4==0 || y%3==0 //第二行语句
!(x>y) //第三行语句其中，第一行语句用于判断 x 的值是否大于 0 且小于或等于 100，只有两个条件同时成立结果才为真（true）。
第二行语句用于判断 y 的值是否能被 4 或者 3 整除，只要有一个条件成立，结果就为真（true）。
第三行语句先比较 x 和 y，再将比较结果取反，即如果 x 大于 y 成立，则结果为假（false），否则为真（true）。

java 中 和 && 这类的符号都表示什么？

分析如下：
位运算的或是“ |” 与时 “&”，"||" 逻辑或， "&&"是逻辑与！例如：(a==1 && b==1) 即表示 在a==1 b==1两个条件需要同时满足，返回结果才是 true(a==1 || b==1) 即表示 在a==1 b==1有一个条件需要满足，返回结果就是true
扩展资料：
发展历程
20世纪90年代，硬件领域出现了单片式计算机系统，这种价格低廉的系统一出现就立即引起了自动控制领域人员的注意，因为使用它可以大幅度提升消费类电子产品（如电视机顶盒、面包烤箱、移动电话等）的智能化程度。
Sun公司为了抢占市场先机，在1991年成立了一个称为Green的项目小组，帕特里克、詹姆斯·高斯林、麦克·舍林丹和其他几个工程师一起组成的工作小组在加利福尼亚州门洛帕克市沙丘路的一个小工作室里面研究开发新技术，专攻计算机在家电产品上的嵌入式应用。
由于C++所具有的优势，该项目组的研究人员首先考虑采用C++来编写程序。但对于硬件资源极其匮乏的单片式系统来说，C++程序过于复杂和庞大。另外由于消费电子产品所采用的嵌入式处理器芯片的种类繁杂，如何让编写的程序跨平台运行也是个难题。
为了解决困难，他们首先着眼于语言的开发，假设了一种结构简单、符合嵌入式应用需要的硬件平台体系结构并为其制定了相应的规范，其中就定义了这种硬件平台的二进制机器码指令系统（即后来成为“字节码”的指令系统），以待语言开发成功后，能有半导体芯片生产商开发和生产这种硬件平台。
对于新语言的设计，Sun公司研发人员并没有开发一种全新的语言，而是根据嵌入式软件的要求，对C++进行了改造，去除了留在C++的一些不太实用及影响安全的成分，并结合嵌入式系统的实时性要求，开发了一种称为Oak的面向对象语言。
由于在开发Oak语言时，尚且不存在运行字节码的硬件平台，所以为了在开发时可以对这种语言进行实验研究，他们就在已有的硬件和软件平台基础上，按照自己所指定的规范，用软件建设了一个运行平台，整个系统除了比C++更加简单之外，没有什么大的区别。
1992年的夏天，当Oak语言开发成功后，研究者们向硬件生产商进行演示了Green操作系统、Oak的程序设计语言、类库和其硬件，以说服他们使用Oak语言生产硬件芯片，但是，硬件生产商并未对此产生极大的热情。因为他们认为，在所有人对Oak语言还一无所知的情况下，就生产硬件产品的风险实在太大了，所以Oak语言也就因为缺乏硬件的支持而无法进入市场，从而被搁置了下来。
1994年6、7月间，在经历了一场历时三天的讨论之后，团队决定再一次改变了努力的目标，这次他们决定将该技术应用于万维网。他们认为随着Mosaic浏览器的到来，因特网正在向同样的高度互动的远景演变，而这一远景正是他们在有线电视网中看到的。作为原型，帕特里克·诺顿写了一个小型万维网浏览器WebRunner。
1995年，互联网的蓬勃发展给了Oak机会。业界为了使死板、单调的静态网页能够“灵活”起来，急需一种软件技术来开发一种程序，这种程序可以通过网络传播并且能够跨平台运行。于是，世界各大IT企业为此纷纷投入了大量的人力、物力和财力。
这个时候，Sun公司想起了那个被搁置起来很久的Oak，并且重新审视了那个用软件编写的试验平台，由于它是按照嵌入式系统硬件平台体系结构进行编写的，所以非常小，特别适用于网络上的传输系统，而Oak也是一种精简的语言，程序非常小，适合在网络上传输。
Sun公司首先推出了可以嵌入网页并且可以随同网页在网络上传输的Applet（Applet是一种将小程序嵌入到网页中进行执行的技术），并将Oak更名为Java（在申请注册商标时，发现Oak已经被人使用了，再想了一系列名字之后，最终，使用了提议者在喝一杯Java咖啡时无意提到的Java词语）。
5月23日，Sun公司在Sun world会议上正式发布Java和HotJava浏览器。IBM、Apple、DEC、Adobe、HP、Oracle、Netscape和微软等各大公司都纷纷停止了自己的相关开发项目，竞相购买了Java使用许可证，并为自己的产品开发了相应的Java平台。
1996年1月，Sun公司发布了Java的第一个开发工具包（JDK 1.0），这是Java发展历程中的重要里程碑，标志着Java成为一种独立的开发工具。9月，约8.3万个网页应用了Java技术来制作。10月，Sun公司发布了Java平台的第一个即时（JIT）编译器。
1997年2月，JDK 1.1面世，在随后的3周时间里，达到了22万次的下载量。4月2日，Java One会议召开，参会者逾一万人，创当时全球同类会议规模之纪录。9月，Java Developer Connection社区成员超过10万。
1998年12月8日，第二代Java平台的企业版J2EE发布。1999年6月，Sun公司发布了第二代Java平台（简称为Java2）的3个版本：J2ME（Java2 Micro Edition，Java2平台的微型版），应用于移动、无线及有限资源的环境；J2SE（Java 2 Standard Edition，Java 2平台的标准版），应用于桌面环境；J2EE（Java 2Enterprise Edition，Java 2平台的企业版），应用于基于Java的应用服务器。Java 2平台的发布，是Java发展过程中最重要的一个里程碑，标志着Java的应用开始普及。
1999年4月27日，HotSpot虚拟机发布。HotSpot虚拟机发布时是作为JDK 1.2的附加程序提供的，后来它成为了JDK 1.3及之后所有版本的Sun JDK的默认虚拟机。
2000年5月，JDK1.3、JDK1.4和J2SE1.3相继发布，几周后其获得了Apple公司Mac OS X的工业标准的支持。2001年9月24日，J2EE1.3发布。2002年2月26日，J2SE1.4发布。自此Java的计算能力有了大幅提升，与J2SE1.3相比，其多了近62%的类和接口。在这些新特性当中，还提供了广泛的XML支持、安全套接字（Socket）支持（通过SSL与TLS协议）、全新的I/OAPI、正则表达式、日志与断言。
2004年9月30日，J2SE1.5发布，成为Java语言发展史上的又一里程碑。为了表示该版本的重要性，J2SE 1.5更名为Java SE 5.0（内部版本号1.5.0），代号为“Tiger”，Tiger包含了从1996年发布1.0版本以来的最重大的更新，其中包括泛型支持、基本类型的自动装箱、改进的循环、枚举类型、格式化I/O及可变参数。
2005年6月，在Java One大会上，Sun公司发布了Java SE 6。此时，Java的各种版本已经更名，已取消其中的数字2，如J2EE更名为JavaEE，J2SE更名为JavaSE，J2ME更名为JavaME。
2006年11月13日，Java技术的发明者Sun公司宣布，将Java技术作为免费软件对外发布。Sun公司正式发布的有关Java平台标准版的第一批源代码，以及Java迷你版的可执行源代码。从2007年3月起，全世界所有的开发人员均可对Java源代码进行修改 。
2009年，甲骨文公司宣布收购Sun 。2010年，Java编程语言的共同创始人之一詹姆斯·高斯林从Oracle公司辞职。2011年，甲骨文公司举行了全球性的活动，以庆祝Java7的推出，随后Java7正式发布。2014年，甲骨文公司发布了Java8正式版 。
资料来源：百度百科：Java发展历程
java 中|| 和 &&都是逻辑运算符。
1、||
"||"是简洁或逻辑运算符
示例：a||b（其中a、b都代表一个条件）
运算规则：如果a、b均为true时，结果才为true；如果a、b中有一者为false，结果为false
2、&&
"&&"是简洁或逻辑运算符
示例：a&&b（其中a、b都代表一个条件）
运算规则：如果a、b均为false时，结果才为flase，如果a、b中有一者为true，结果为true。
扩展资料
java中的逻辑运算符及优先级：
一元：！（逻辑非）、&（逻辑与）、|（逻辑或）。
二元：&&（简洁与）、||（简洁或）。
以上三种逻辑运算符中，逻辑非 ! 的优先级最高，逻辑与 &、逻辑或| 次之，简洁或 || 优先级最低。即算术、逻辑、赋值运算符的优先级顺序为：
逻辑非 ! >算术 > 逻辑与 &、逻辑或 | >简洁与&&、简洁或||> 赋值=
参考资料来源：百度百科——逻辑运算符
简单的说||表或连接的两个布尔值，其中有一个或以上为true，这个符号连接的整体返回true，如false||true 返回true。反之两个为false，整体为false
&&符号表且，当连接两个都为true时才返回true，楼主可以多写几个demo看输出值，体会之间的关系。
&&和||是一种逻辑运算符，&&是逻辑与，当两个数都为真，则结果为真。||是逻辑或，两个数任意一个为真，则结果为真。
或者：逻辑或（任一条件成立，为真）
并且：逻辑与（双重条件都成立，才真）
‖ ：逻辑或。一真俱真，都假才假
&& ：逻辑与。一假俱假，都真才真
另：
! ：逻辑非。真变假，假变真
&&和||是一种逻辑运算符，&&是逻辑与，当两个数都为真，则结果为真。||是逻辑或，两个数任意一个为真，则结果为真。
举个例子：
1、a && b
当a、b都为真时，结果为真。有一个为假或者都为假时结果为假。
2、a || b
当a、b有一个为真时，结果为真。a、b都为假时结果为假。
扩展资料：
在java中还有其他的逻辑符号，比如：！、|、 &
“！”是非运算符号，比如a为真，则！a则为假。a如果为假，则！a为真。
而“|”也是逻辑或，“&”也是逻辑与，但是他们与“||”和“&&”有些区别，区别如下：
“&”与“|”无论第一个判断条件是否成立，逻辑运算符前后两个条件都会进行判断。
“&&”与“||”，前者第一个条件不成立，后面的条件均不进行判断，返回false；后者第一个条件成立，后面的条件均不进行判断,返回true。

JAVA中&&和 是什么意思？怎么用

&&表示与，前后两个操作数必须都为true才返回true，否则返回false。它是先计算左边的操作数，如果左边的操作数为false，直接返回false，根本不会去计算右边的操作数。
||表示或，只要两个操作数中有一个是true，就可以返回true，否则返回false。从左往右进行计算，当第一个操作数为true时，直接返回true，不再进行后面操作数的计算。
扩展资料：
Java运算符基本分为六类：算数运算符、赋值运算符、比较/关系运算符、逻辑运算符、位运算符、三元/三目/条件运算符。
1、算数运算符都包括：加（+）、减（-）、乘（*）、除（/）、取模（%）、自增（++）、自减（–）、字符串连接符（+）。
2、赋值运算符包括：=（等于） +=（加等） -=（减等） *=（乘等） /=（除等） %=（取余等） &=（与等） |=（或等） ^=（异或等） <<=（左移等） >>=（右移等） >>>=（无符号右移等） 。
3、关系 运算符/比较运算符包括：==等于、!= 不等于、>(大于) 、<（小于）、>=（大于等于）、<=（小于等于）、instanceof（判断对象于实例的关系）。
4、逻辑运算符包括：&与（And）、|或（Or）、!非(Not)、^异或、&&短路与、||短路或 。
5、位运算符包括：&（与）、|（或）、 ^（异或）、<<（左移）、>>（右移）、>>>（无符号右移）、~（取反） 。
6、三元运算符格式：逻辑值 ？ 表达式1 ：表达式2。
&&可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为true时，整个运算结果才为true，否则，只要有一方为false，则结果为false。
&&还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式，例如，对于if(str != null && !str.equals(“”))表达式，当str为null时，后面的表达式不会执行，所以不会出现NullPointerException
||可以作逻辑或运算符，表示逻辑或（or），当运算符有一边为true时，整个运算结果为true！
&&在Java中是逻辑操作符，也叫条件操作符
使用方法是 x&&y
功能描述： “条件与”：x和y均为true,取值是true，否则取值是false
&和&&都需要两个操作数的值都是true时，才取值true,但是两个操作符还是有区别的：
例如：（x>y）&&(x>z)
如果x>y的值是false,那么x>z的值将不再计算，（x>y）&&(x>z)直接取值false;
而（x>y）&(x>z)；
即使x>y的值是false那么x>z的值仍需计算，尽管x>z的值不会影响x>y&x>z的结果。这就是为什么称&&为“条件与”的理由：只有在满足第一个操作数的值为true的条件下，才计算第二个操作数的值。
JAVA中&&意思是“条件与”逻辑操作符，使用方法是x&&y，功能描述：x和y均为true,取值是true，否则取值是false。
JAVA中｜｜意思是“条件或”逻辑操作符，使用方法是x｜｜y，功能描述：x和y有一个为true，取值是true，否则取值是false。
扩展资料：
JAVA语言中进行逻辑表达式求值运算时，不但要注意逻辑运算符本身的运算规则，而且还必须从最左边一个计算部分开始，按照逻辑运算的规则计算该部分的值。每计算完一个部分就与该部分右边紧靠着的逻辑运算符根据真值表进行逻辑值判断。
在逻辑表达式的求解过程中，任何时候只要逻辑表达式的值已经可以确定，则求解过程不再进行，求解结束。
参考资料来源：
百度百科——&&
百度百科——||

java里的&&， 和!()什么意思,还有==和=又什么区别

&&是逻辑运算符(与),只有当前后的条件都为真的,才返回true,只要有一个为假,就返回false
||是逻辑运算符(或),当前后的条件有一个为真或者都为真时,就返回true,都为假时就返回false
!是逻辑运算符(非),作用是取反,如果条件为真,就返回false,如果条件为假,就返回true
==是比较运算符,判断前后两个值是否相等 如果相等就返回true,不等就返回FALSE
=是赋值运算符,将后面的数值赋值给前面的变量
&&是并且的意思 区别于&的地方是 在&&的过程中如果有一个条件为FALSE 那么该逻辑便不再进行下去 &则是无论条件如何 都会执行完全部的判断
|| 是或者的意思 其余同上
!()这个不是什么东西 其实就是将括号内BOOLEAN逆转而已
==是逻辑运算符 而=是赋值语句 比如
a == b 这个是返回一个BOOLEAN值
而a = b 的意思是 a 等于b
&&:and,即并且的关系
||：or 或者的关系
!()对括号中的进行否定
==和=区别：前者是逻辑比较，后者是赋值
&&并且
||或者
==相等
=赋值
与，或，非，等，赋值
&&: 是逻辑运算符，代表与（就是并且），条件都成立，返回值是 true，否则 FALSE
||: 是逻辑运算符，代表或（就是或者），条件中有一者成立，返回值是 true
否则 false
！():是逻辑运算符，代表非（就是取反），把真的变成假的，或者把假的变成真的
==: 比较运算符，判断是否相等
=: 赋值运算符，例: i = 10;

Java中的运算符有哪些

1.算术运算符
Java的算术运算符分为一元运算符和二元运算符。一元运算符只有一个操作数；二元运算符有两个操作数，运算符位于两个操作数之间。算术运算符的操作数必须是数值类型。
(1)一元运算符：
一元运算符有：正（+）、负（－）、加1（++）和减1（－－）4个。
加1、减1运算符只允许用于数值类型的变量，不允许用于表达式中。加1、减1运算符既可放在变量之前（如＋＋i），也可放在变量之后（如i＋＋），两者的差别是：如果放在变量之前（如＋＋i），则变量值先加1或减1，然后进行其他相应的操作（主要是赋值操作）；如果放在变量之后（如i＋＋），则先进行其他相应的操作，然后再进行变量值加1或减1。
直接看这吧
http://wenku.baidu.com/view/ea835643a8956bec0975e379.html
根据不同的功能和用途，Java运算符可以分为以下几类：
算术运算符：用于进行基本的数学运算，如加、减、乘、除等。常用的算术运算符有 + - * / % ++ --。
赋值运算符：用于为变量或常量指定数值或表达式的结果。常用的赋值运算符有 = += -= *= /= %= <<= >>= &= ^= |=。
关系运算符：用于判断两个数据的大小或相等关系，返回一个布尔值(true或false)。常用的关系运算符有 < > <= >= == !=。
逻辑运算符：用于进行逻辑与、逻辑或、逻辑非等操作，返回一个布尔值(true或false)。常用的逻辑运算符有 && || !。
位运算符：用于对二进制位进行操作，如按位与、按位或、按位异或等。常用的位运算符有 & | ^

Java 语言中逻辑 “ ” “！” “^” 运算符的用法是什么？

“||”是或的意思，即有一个成立，则满足条件。
如：
if(a>3||a<0){
}
“！”是非的意思，即否定，取反。
如：if(a!=3){
}
“||”是或的意思，即有一个成立，则满足条件。
如： if(a>3||a<0){ }
“！”是非的意思，即否定，取反。
如：if(a!=3){ }
一个办法，利用System.out.print测试
例如：System.out.print(a^2);

java逻辑运算符作用

逻辑运算符：
&(与) |（或） ！（反）
&：当两边同时为真时，结果为真，否则为假
| ：当两边有一边为真时，结果为真，否则为假
! ：真值变假值，假值变真值
逻辑运算又称布尔运算
逻辑运算 (logical operators) 通常用来测试真假值。最常见到的逻辑运算就是循环的处理，用来判断是否该离开循环或继续执行循环内的指令。
符号 意义
< 小于
> 大于
<= 小于或等于
>= 大于或等于
== 等于
!= 不等于
&& 而且 (And)
and 而且 (And)
|| 或者 (Or)
or 或者 (Or)
xor 异或 (Xor)
! 非 (Not)
组合\结果\运算符.....And.......Or.........Xor
0......0.......................0..........0............0
1......0.......................0..........1............1
0......1.......................0..........1............1
1......1.......................1..........1............0
简单的说
And:同为真时为真
Or:同为假时为假
Xor:相同为假
运算符 含义 示例
~ 按位非（NOT） b = ~a
& 按位与（AND） c = a & b
| 按位或（OR） c = a | b
^ 按位异或（XOR） c = a ^ b
>> 右移 b = a >> 2
>>> 右移，左边空出的位以0填充 b = a >>> 2
<< 左移 b = a << 1

当然同样有 &=，|=，^=，>>=，>>>=，<<=。

参考： http://www.360doc.com/content/11/0129/14/18042_89763765.shtml
里面有具体例子。。
＆ －－－ 与操作 理解为and
｜ －－－ 或操作 理解为or
＞＞ －－ 用符号位填充左侧的位右移
＜＜ －－ 左移
＞＞＞ － 用"0"填充前面的位右移
1&1=1
1&0=1
0&0=0
0&1=1
一般如果要判断两个条件时用&&连接：
如：
if(i<10&&i>0)表示如果变量i的值即大于0，且小10，就执行下面的代码。
boolean ok = false；
if(!ok)
{
System.out.println("ok")；
}
//结果会打印ok；
if(!End)return;和if(End==false)return
if(End)return;和if(End==true)return;是一个意思。
扩展资料：
运算符指明对操作数的运算方式。组成表达式的Java操作符有很多种。运算符按照其要求的操作数数目来分，可以有单目运算符、双目运算符和三目运算符，它们分别对应于1个、2个、3个操作数。运算符按其功能来分，有算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符和其他运算符。
参考资料来源：百度百科-JAVA语言运算符

java中的位运算子及其用法。

java中的位运算子及其用法。 位逻辑运算子有“与”（AND）、“或”（OR）、“异或（XOR）”、“非（NOT）”，分别用“&”、“|”、“^”、“~”表示。 下面的例子说明了位逻辑运算子： Demonstrate the biise logical operators. class BitLogic { public static void main(String args[]) { String binary[] = { "0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111", "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111" }; int a = 3; 0 + 2 + 1 or 0011 in binary int b = 6; 4 + 2 + 0 or 0110 in binary int c = a | b; int d = a & b; int e = a ^ b; int f = (~a & b) | (a & ~b); int g = ~a & 0x0f; System.out.println(" a = " + binary[a]); System.out.println(" b = " + binary[b]); System.out.println(" a|b = " + binary[c]); System.out.println(" a&b = " + binary[d]); System.out.println(" a^b = " + binary[e]); System.out.println("~a&b|a&~b = " + binary[f]); System.out.println(" ~a = " + binary[g]); } } 在本例中，变数a与b对应位的组合代表了二进位制数所有的 4 种组合模式：0-0，0-1，1-0，和1-1。“|”运算子和“&”运算子分别对变数a与b各个对应位的运算得到了变数c和变数d的值。对变数e和f的赋值说明了“^”运算子的功能。字串阵列binary代表了0到15对应的二进位制的值。在本例中，阵列各元素的排列顺序显示了变数对应值的二进位制程式码。阵列之所以这样构造是因为变数的值n对应的二进位制程式码可以被正确的储存在阵列对应元素binary[n]中。例如变数a的值为3，则它的二进位制程式码对应地储存在阵列元素binary[3]中。~a的值与数字0x0f （对应二进位制为0000 1111）进行按位与运算的目的是减小~a的值，保证变数g的结果小于16。因此该程式的执行结果可以用阵列binary对应的元素来表示。该程式的输出如下： a = 0011 b = 0110 a|b = 0111 a&b = 0010 a^b = 0101 ~a&b|a&~b = 0101 ~a = 1100 左移运算子 左移运算子<
<使指定值的所有位都左移规定的次数。它的通用格式如下所示： value << num="num" 这里，num指定要移位值value移动的位数。也就是，左移运算子<<使指定值的所有位都左移num位。每左移一个位，高阶位都被移出（并且丢弃），并用0填充右边。这意味着当左移的运算数是int型别时，每移动1位它的第31位就要被移出并且丢弃；当左移的运算数是long型别时，每移动1位它的第63位就要被移出并且丢弃。 在对byte和short型别的值进行移位运算时，你必须小心。因为你知道java在对表达式求值时，将自动把这些型别扩大为 int型，而且，表示式的值也是int型 。对byte和short型别的值进行移位运算的结果是int型，而且如果左移不超过31位，原来对应各位的值也不会丢弃。但是，如果你对一个负的byte或者short型别的值进行移位运算，它被扩大为int型后，它的符号也被扩充套件。这样，整数值结果的高位就会被1填充。因此，为了得到正确的结果，你就要舍弃得到结果的高位。这样做的最简单办法是将结果转换为byte型。下面的程式说明了这一点： left shifting a byte value. class byteshift { public static void main(string args[]) b; int i; i 2; b="(byte)" (a 2); system.out.println("original of a: " + a); system.out.println("i and b: b); } 该程式产生的输出下所示： original 64 256 0 因变数a在赋值表示式中，故被扩大为int型，64（0100 0000）被左移两次生成值256（10000 0000）被赋给变数i。然而，经过左移后，变数b中惟一的1被移出，低位全部成了0，因此b的值也变成了0。 既然每次左移都可以使原来的运算元翻倍，程式设计师们经常使用这个办法来进行快速的2的乘法。但是你要小心，如果你将1移进高阶位（31或63位），那么该值将变为负值。下面的程式说明了这一点： as quick way to multiply by 2. multbytwo for(i="0;" i
>使指定值的所有位都右移规定的次数。它的通用格式如下所示： value >> num 这里，num指定要移位值value移动的位数。也就是，右移运算子>>使指定值的所有位都右移num位。 下面的程式片段将值32右移2次，将结果8赋给变数a: int a = 32; a = a >> 2; a now contains 8 当值中的某些位被“移出”时，这些位的值将丢弃。例如，下面的程式片段将35右移2次，它的2个低位被移出丢弃，也将结果8赋给变数a: int a = 35; a = a >> 2; a still contains 8 用二进位制表示该过程可以更清楚地看到程式的执行过程： 00100011 35 >> 2 00001000 8 将值每右移一次，就相当于将该值除以2并且舍弃了余数。你可以利用这个特点将一个整数进行快速的2的除法。当然，你一定要确保你不会将该数原有的任何一位移出。 右移时，被移走的最高位（最左边的位）由原来最高位的数字补充。例如，如果要移走的值为负数，每一次右移都在左边补1，如果要移走的值为正数，每一次右移都在左边补0，这叫做符号位扩充套件（保留符号位）（sign extension），在进行右移操作时用来保持负数的符号。例如，–8 >> 1 是–4，用二进位制表示如下： 11111000 –8 >>1 11111100 –4 一个要注意的有趣问题是，由于符号位扩充套件（保留符号位）每次都会在高位补1，因此-1右移的结果总是–1。有时你不希望在右移时保留符号。例如，下面的例子将一个byte型的值转换为用十六进位制表示。注意右移后的值与0x0f进行按位与运算，这样可以舍弃任何的符号位扩充套件，以便得到的值可以作为定义阵列的下标，从而得到对应阵列元素代表的十六进位制字元。 Masking sign extension. class HexByte { 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 = 0xf1 无符号右移 正如上面刚刚看到的，每一次右移，>>运算子总是自动地用它的先前最高位的内容补它的最高位。这样做保留了原值的符号。但有时这并不是我们想要的。例如，如果你进行移位操作的运算数不是数字值，你就不希望进行符号位扩充套件（保留符号位）。当你处理画素值或图形时，这种情况是相当普遍的。在这种情况下，不管运算数的初值是什么，你希望移位后总是在高位（最左边）补0。这就是人们所说的无符号移动（unsigned shift）。这时你可以使用Java的无符号右移运算子>>>，它总是在左边补0。下面的程式段说明了无符号右移运算子>>>。在本例中，变数a被赋值为-1，用二进位制表示就是32位全是1。这个值然后被无符号右移24位，当然它忽略了符号位扩充套件，在它的左边总是补0。这样得到的值255被赋给变数a。 int a = -1; a = a >>> 24; 下面用二进位制形式进一步说明该操作： 11111111 11111111 11111111 11111111 int型- 1的二进位制程式码 >>> 24 无符号右移24位 00000000 00000000 00000000 11111111 int型255的二进位制程式码由于无符号右移运算子>>>只是对32位和64位的值有意义，所以它并不像你想象的那样有用。因为你要记住，在表示式中过小的值总是被自动扩大为int型。这意味着符号位扩充套件和移动总是发生在32位而不是8位或16位。这样，对第7位以0开始的byte型的值进行无符号移动是不可能的，因为在实际移动运算时，是对扩大后的32位值进行操作。下面的例子说明了这一点： Unsigned shifting a byte value. class ByteUShift { 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; byte c = (byte) (b >> 4); byte d = (byte) (b >>> 4); byte e = (byte) ((b & 0xff) >> 4); System.out.println(" b = 0x" + hex[(b >> 4) & 0x0f] + hex[b & 0x0f]); System.out.println(" b >> 4 = 0x" + hex[(c >> 4) & 0x0f] + hex[c & 0x0f]); System.out.println(" b >>> 4 = 0x" + hex[(d >> 4) & 0x0f] + hex[d & 0x0f]); System.out.println("( b & 0xff) >> 4 = 0x" + hex[(e >> 4) & 0x0f] + hex[e & 0x0f]); } } 该程式的输出显示了无符号右移运算子>>>对byte型值处理时，实际上不是对byte型值直接操作，而是将其扩大到int型后再处理。在本例中变数b被赋为任意的负byte型值。对变数b右移4位后转换为byte型，将得到的值赋给变数c，因为有符号位扩充套件，所以该值为0xff。对变数b进行无符号右移4位操作后转换为byte型，将得到的值赋给变数d，你可能期望该值是0x0f，但实际上它是0xff，因为在移动之前变数b就被扩充套件为int型，已经有符号扩充套件位。最后一个表示式将变数b的值通过按位与运算将其变为8位，然后右移4位，然后将得到的值赋给变数e，这次得到了预想的结果0x0f。由于对变数d（它的值已经是0xff）进行按位与运算后的符号位的状态已经明了，所以注意，对变数d再没有进行无符号右移运算。 B = 0xf1 b >> 4 = 0xff b >>> 4 = 0xff (b & 0xff) >> 4 = 0x0f 位运算子赋值 所有的二进位制位运算子都有一种将赋值与位运算组合在一起的简写形式。例如，下面两个语句都是将变数a右移4位后赋给a： a = a >> 4; a >>= 4; 同样，下面两个语句都是将表示式a OR b运算后的结果赋给a： a = a | b; a |= b; 下面的程式定义了几个int型变数，然后运用位赋值简写的形式将运算后的值赋给相应的变数： class OpBitEquals { public static void main(String args[]) { int a = 1; int b = 2; int c = 3; a |= 4; b >>= 1; c <<= 1; a ^= c; System.out.println("a = " + a); System.out.println("b = " + b); System.out.println("c = " + c); } } 该程式的输出如下所示： a = 3 b = 1 c = 6

java中的按位运算子 与 0&&0 =0 1&&0 =0 0&&1 =0 1&&1 =1 或 0||0 =0 1||0 =1 0||1 =1 1||1 =1 异或是 1^0=1 0^1=1 0^0=0 1^1=0 例子 11001010 与 00011011 按位与 按位或 按位异或 00001010 11011011 11010001

什么是Java的位运算子？ 位运算子用来对二进位制位进行操作,位 运 算 符 (＞＞,＜＜,＞＞＞,&,|,^,～ ) ,位运 算 符 中 ,除 ～ 以 外 ,其余 均 为 二 元 运 算 符 。 操 作 数 只 能 为 整 型 和字 符 型 数 据 。 比如‘>>’ 这个就相当于乘以2.

c++中的位运算子号 C++位运算子有以下两类： 1 位逻辑运算子：&（位“与”）、^（位“异或”）、|（位“或”）和~（位“取反”） 2 移位运算子：<<（左移）和>>(右移). 位“与”、位“或”和位“异或”运算子都是双目运算子，其结合性都是从左向右的，优先顺序高于逻辑运算子，低于比较运算子，且从高到低依次为&、^、|

c++中按位运算子的用法 这个是C++中的基础，你可以看看人家的部落格。 :m.blog.csdn./article/details?id=52196039

java中位运算子详解 运算子那多了去了 算术运算子 + - * / % 分别是加减乘除求余 在这里要特别注意有个晋升现象.是指低于int的三种类型(byte short char)进行算术运算后会自动提升成int型别列如 byte a=20; byte b=30; byte c=a+b;这就错了应该写成byte c=(byte)(a+b);或者 int c =a+b; 比较运算子 即< ,> ,<=, >= ,==, !=分别是小于, 大于, 小于等于,大于等于,不等于 它的结果是一个Boolean 型别 逻辑运算子 或(||) 与(&&) 非(!) or and not 赋值运算子 最简单的是"="用来为常量或者变数指定值注意不能为运算式赋值 还有其他赋值运算子如下 += 加等 把变数加上右侧的值然后再赋值给自身 -= 减等 把变数减去右侧的值然后再赋值给自身 *= 乘等 把变数乘以右侧的值然后再赋值给自身 /= 除等 把变数除以右侧的值然后再赋值给自身 %= 取余等 把变数和右侧的值取余然后再赋值给自身 还有二进位制运算子 位运算子 移位运算子.... ++ 递增 -- 递减 条件?值1:值2 条件运算子

java中的逻辑符号，运算子（位运算子）个代表什么 算数运算子，+-*/(+=，-=，*=，、/*) p.s. 1/0 => NaN 无穷大。逻辑运算子，略转义序列符（例举），\b 退格, \t 制表, \n 换行（制图、一般println）, \r 回车, \" 双引号, \' 单引号p.s. 取决于os，并不常用。递增/减 ++, --赋值 =比较 >=，<=, ==位移 <<，>>, >>>p.s. 图形用到注释， 行注释，/* */段注释型别转换， a = (int)b; 括号。条件， if()... == a ? true : false 三目运算。正则表示式， 应用类，用到这再说。 LZ是学Java的新手吧。嗯，慢慢学

java都有哪些运算子及其用法 Java的运算子可分为4类：算术运算子、关系运算符、逻辑运算子和位运算子。 1.算术运算子 Java的算术运算子分为一元运算子和二元运算子。一元运算子只有一个运算元；二元运算子有两个运算元，运算子位于两个运算元之间。算术运算子的运算元必须是数值型别。 (1)一元运算子： 一元运算子有：正（+）、负（－）、加1（++）和减1（－－）4个。 加1、减1运算子只允许用于数值型别的变数，不允许用于表示式中。加1、减1运算子既可放在变数之前（如＋＋i），也可放在变数之后（如i＋＋），两者的差别是：如果放在变数之前（如＋＋i），则变数值先加1或减1，然后进行其他相应的操作（主要是赋值操作）；如果放在变数之后（如i＋＋），则先进行其他相应的操作，然后再进行变数值加1或减1。 例如： int i=6，j，k，m，n; j = +i; 取原值，即j=6 k = -i; 取负值，即k=-6 m = i++; 先m=i,再i=i+1，即m=6，i=7 m = ++i; 先i=i+1,再m=i，即i=7，m=7 n = j--; 先n=j,再j=j-1，即n=6，j=5 n = --j; 先j=j-1,再n=j，即j=5，n=5 在书写时还要注意的是：一元运算子与其前后的运算元之间不允许有空格，否则编译时会出错。 (2)二元运算子 二元运算子有：加（+）、减（－）、乘（*）、除（／）、取余（%）。其中+、－、*、／完成加、减、乘、除四则运算，%是求两个运算元相除后的余数。 %求余操作举例： a % b = a － (a / b) * b 取余运算子既可用于两个运算元都是整数的情况，也可用于两个运算元都是浮点数（或一个运算元是浮点数）的情况。当两个运算元都是浮点数时，例如7.6 % 2.9时，计算结果为：7.6 － 2 * 2.9 = 1.8。 当两个运算元都是int型别数时，a%b的计算公式为： a % b = a － （int）(a / b) * b 当两个运算元都是long型别（或其他整数型别）数时，a%b的计算公式可以类推。 当参加二元运算的两个运算元的资料型别不同时，所得结果的资料型别与精度较高（或位数更长）的那种资料型别一致。

例如： 7 / 3 整除，运算结果为2 7.0 / 3 除法，运算结果为2.33333,即结果与精度较高的型别一致 7 % 3 取余，运算结果为1 7.0 % 3 取余，运算结果为1.0 -7 % 3 取余，运算结果为-1，即运算结果的符号与左运算元相同 7 % -3 取余，运算结果为1，即运算结果的符号与左运算元相同 2.关系运算符 关系运算符用于比较两个数值之间的大小，其运算结果为一个逻辑型别的数值。关系运算符有六个：等于（==）、不等于（!=）、大于（>）、大于等于（>=）、小于（<）、小于等于（<=）。

例如： 9 <= 8 运算结果为false 9.9 >= 8.8 运算结果为true 'A' < 'a' 运算结果为true，因字元'A'的Unicode编码值小于字元'a'的 要说明的是，对于大于等于（或小于等于）关系运算符来说，只有大于和等于两种关系运算都不成立时其结果值才为false，只要有一种（大于或等于）关系运算成立其结果值即为true。例如，对于9 <= 8，9既不小于8也不等于8，所以9 <= 8 的运算结果为false。对于9 >= 9，因9等于9，所以9 >= 9的运算结果为true。 3.逻辑运算子 逻辑运算子要求运算元的资料型别为逻辑型，其运算结果也是逻辑型值。逻辑运算子有：逻辑与（&&）、逻辑或（||）、逻辑非（!）、逻辑异或（^）、逻辑与（&）、逻辑或（|）。 真值表是表示逻辑运算功能的一种直观方法，其具体方法是把逻辑运算的所有可能值用表格形式全部罗列出来。Java语言逻辑运算子的真值表如下： 逻辑运算子的真值表 A B A&&B A||B !A A^B A&B A|B false false false false true false false false true false false true false true false true false true false true true true false true true true true true false false true true 前两列是参与逻辑运算的两个逻辑变数，共有4种可能，所以表2.5共有4行。后6列分别是6个逻辑运算子在逻辑变数A和逻辑变数B取不同数值时的运算结果值。 要说明的是，两种逻辑与（&&和&）的运算规则基本相同，两种逻辑或（||和|）的运算规则也基本相同。其区别是：&和|运算是把逻辑表示式全部计算完，而&&和||运算具有短路计算功能。所谓短路计算，是指系统从左至右进行逻辑表示式的计算，一旦出现计算结果已经确定的情况，则计算过程即被终止。对于&&运算来说，只要运算子左端的值为false，则因无论运算子右端的值为true或为false，其最终结果都为false。所以，系统一旦判断出&&运算子左端的值为false，则系统将终止其后的计算过程；对于 || 运算来说，只要运算子左端的值为true，则因无论运算子右端的值为true或为false，其最终结果都为true。所以，系统一旦判断出|| 运算子左端的值为true，则系统将终止其后的计算过程。

例如，有如下逻辑表示式： (i>=1) && (i<=100) 此时，若i等于0，则系统判断出i>=1的计算结果为false后，系统马上得出该逻辑表示式的最终计算结果为false，因此，系统不继续判断i<=100的值。短路计算功能可以提高程式的执行速度。 作者建议读者：在程式设计时使用&&和||运算子，不使用&和|运算子。 用逻辑与（&&）、逻辑或（||）和逻辑非（!）可以组合出各种可能的逻辑表示式。逻辑表示式主要用在 if、while等语句的条件组合上。 例如： int i = 1; while(i>=1) && (i<=100) i++; 回圈过程 上述程式段的回圈过程将i++语句回圈执行100次。 4.位运算子 位运算是以二进位制位为单位进行的运算，其运算元和运算结果都是整型值。 位运算子共有7个，分别是：位与（&）、位或（|）、位非（~）、位异或（^）、右移（>>）、左移（<<）、0填充的右移（>>>）。 位运算的位与（&）、位或（|）、位非（~）、位异或（^）与逻辑运算的相应操作的真值表完全相同，其差别只是位运算操作的运算元和运算结果都是二进位制整数，而逻辑运算相应操作的运算元和运算结果都是逻辑值。

位运算示例 运算子 名称 示例 说明 & 位与 x&y 把x和y按位求与 | 位或 x|y 把x和y按位求或 ~ 位非 ~x 把x按位求非 ^ 位异或 x^y 把x和y按位求异或 >> 右移 x>>y 把x的各位右移y位 << 左移 x<

>> 右移 x>>>y 把x的各位右移y位，左边填0 举例说明： （1）有如下程式段： int x = 64; x等于二进位制数的01000000 int y = 70; y等于二进位制数的01000110 int z = x&y z等于二进位制数的01000000 即运算结果为z等于二进位制数01000000。位或、位非、位异或的运算方法类同。 （2）右移是将一个二进位制数按指定移动的位数向右移位，移掉的被丢弃，左边移进的部分或者补0（当该数为正时），或者补1（当该数为负时）。这是因为整数在机器内部采用补码表示法，正数的符号位为0，负数的符号位为1。例如，对于如下程式段： int x = 70; x等于二进位制数的01000110 int y = 2; int z = x>>y z等于二进位制数的00010001 即运算结果为z等于二进位制数00010001，即z等于十进位制数17。 对于如下程式段： int x = -70; x等于二进位制数的11000110 int y = 2; int z = x>>y z等于二进位制数的11101110 即运算结果为z等于二进位制数11101110，即z等于十进位制数-18。要透彻理解右移和左移操作，读者需要掌握整数机器数的补码表示法。 （3）0填充的右移（>>>）是不论被移动数是正数还是负数，左边移进的部分一律补0。 5.其他运算子 （1）赋值运算子与其他运算子的简捷使用方式 赋值运算子可以与二元算术运算子、逻辑运算子和位运算子组合成简捷运算子，从而可以简化一些常用表示式的书写。 赋值运算子与其他运算子的简捷使用方式 运算子 用法 等价于 说明 += s+=i s=s+i s，i是数值型 -= s-=i s=s-i s，i是数值型 *= s*=i s=s*i s，i是数值型 /= s/=i s=s/i s，i是数值型 %= s%=i s=s%i s，i是数值型 &= a&=b a=a&b a，b是逻辑型或整型 |= a|=b a=a|b a，b是逻辑型或整型 ^= A^=b a=a^b a，b是逻辑型或整型 <<= s<<=i s=s<
>= s>>=i s=s>>i s，i是整型 >>>= s>>>=i s=s>>>i s，i是整型 （2）方括号[]和圆括号（）运算子 方括号[]是阵列运算子，方括号[]中的数值是阵列的下标，整个表示式就代表阵列中该下标所在位置的元素值。 圆括号（）运算子用于改变表示式中运算子的优先顺序。 （3）字串加（+）运算子 当运算元是字串时，加（+）运算子用来合并两个字串；当加（+）运算子的一边是字串，另一边是数值时，机器将自动将数值转换为字串，这种情况在输出语句中很常见。如对于如下程式段： int max = 100; System.out.println（"max = "+max）; 计算机萤幕的输出结果为：max = 100，即此时是把变数max中的整数值100转换成字串100输出的。 （4）条件运算子（？：） 条件运算子（？：）的语法形式为：

（6）物件运算子instanceof 物件运算子instanceof用来测试一个指定物件是否是指定类（或它的子类）的例项，若是则返回true，否则返回false。 （7）点运算子 点运算子“.”的功能有两个：一是引用类中成员，二是指示包的层次等级。

6.运算子的优先顺序 以下按优先顺序从高到低的次序列出Java语言中的所有运算子，表中结合性一列中的“左?右”表示其运算次序为从左向右，“右?左”表示其运算次序为从右向左。 优先顺序 运算子 结合性 1 . [] () ; , 2 ++ ―― += ! ~ +(一元) -(一元) 右?左 3 * / % 左?右 4 +(二元) -(二元) 左?右 5 << >> >>> 左?右 6 < > <= >= instanceof 左?右 7 = = != 左?右 8 & 左?右 9 ^ 左?右 10 | 左?右 11 && 左?右 12 || 左?右 13 ?： 右?左 14 = *= /= %= += －= <<= >>= >>>= &= ^= |= 右?左 --感谢原作者。

如何理解vba中逻辑运算子的位运算子 位运算子并不是逻辑运算子，逻辑运算子包括或、与、非、异或。

java 中有同或运算符吗？