Java运算符(优先级、目数)(精)

合集下载

Java 运算符总结

Java 运算符目录1、自增自减运算符 (2)2、算术运算符 (2)3、位运算符 (3)4、逻辑运算符 (5)5、关系运算符 (6)6、短路逻辑运算符 (8)7、赋值运算符 (8)8、Java运算符优先级 (10)9、条件运算符（?:） (11)10、instanceof 运算符 (12)1、自增自减运算符1.1自增（++）自减（--）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数。

1.2前缀自增自减法(++a,--a): 先进行自增或者自减运算，再进行表达式运算。

1.3后缀自增自减法(a++,a--): 先进行表达式运算，再进行自增或者自减运算2、算术运算符算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。

下表列出了所有的算术运算符。

3、位运算符java 定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。

位运算符作用在所有的位上，并且按位运算。

假设a = 60，b = 13;它们的二进制格式表示将如下：4、逻辑运算符下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假下表为Java支持的关系运算符\6、短路逻辑运算符当使用与逻辑运算符时，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。

7、赋值运算符下面是Java语言支持的赋值运算符：8、Java运算符优先级9、条件运算符（?:）条件运算符也被称为三元运算符。

该运算符有3个操作数，并且需要判断布尔表达式的值。

该运算符的主要是决定哪个值应该赋值给变量。

10、instanceof 运算符该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。

instanceof运算符使用格式如下：如果运算符左侧变量所指的对象，是操作符右侧类或接口(class/interface)的一个对象，那么结果为真。

java运算符基础入门

1 运算符1：运算对常量和变量进行操作的过程称为运算。

2：运算符对常量和变量进行操作的符号称为运算符3：操作数参与运算的数据称为操作数4：用运算符把常量或者变量连接起来符号java语法的式子就可以称为表达式。

不同运算符连接的式子体现的是不同类型的表达式。

举例：int a = 3 + 4;这是做了一个加法运算+就是运算符，是算术运算符，我们还有其他很多的运算符3，4就是参与运算的操作数据3 + 4整体其实就是一个算数表达式●+,-,*,/都是比较简单的操作，简单演示即可●+的几种作用：•加法•正数•字符串连接符●除法的时候要注意一个问题：•整数相除，只能得到整数•要想得到小数，可以*1.0●/和%的区别●++和--的应用•单独使用效果相同•参与运算使用，在操作数的前后效果不同●1:基本小题目●int a = 10;●int b = 10;●int c = 10;● a = b++;● c = --a;● b = ++a;● a = c--;●请分别计算出a,b,c的值●2:比较复杂的题目●int a = 4;●int b = (a++)+(++a)+(a*10);●引出运算符的优先级2 赋值运算符●符号：•= , +=, -=, *=, /=, %=•=为基本的赋值运算符，其他的为扩展的赋值运算符●如下操作写出结果•int a,b; a = b = 10;•System.out.println(a); System.out.println(b);•int a = 10; a += 20; System.out.println(a);●面试题•short s=1, s = s+1; short s=1, s+=1;•上面两个代码有没有问题，如果有，那里有问题1:= 赋值号2:+=加赋值把左边和右边的结果赋值给左边。

注意：左边不能是常量3:通过面试题引出+=运算符的特点：有一个隐含的默认转换功能。

实际上等价于：short s = 1;s+=1等价于s=(s的数据类型)(s+1关系运算符●注1：比较运算符的结果都是boolean型，也就是要么是true，要么是false。

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操作符的优先级（从⼤到⼩）和结合性操作优先级结合性1后缀运算符[ ] . ( ) (函数呼叫)从左到右2单⽬运算符! ~ ++ -- +(单操作数) –(单操作数)从右到左3创建new从左到右4乘除* / %从左到右5加减+ -从左到右6移位<< >> >>>从左到右7关系< <= > >= instanceof从左到右8相等== !=从左到右9按位与&从左到右10按位异或^从左到右11按位或|从左到右12逻辑与&&从左到右13逻辑或||从左到右14条件? :从右到左15赋值= += -= *= /= %= ^= <<= >>= >>>=从右到左⼏乎所有运算符都只能操作“主类型”（Primitives）。

例外是“=”、“= =”和“! =”，它们能操作所有对象。

除此以外，String类⽀持“+”和“+=”。

（1）赋值主类型使⽤“A=B”，那么B处的内容就复制到A。

若修改A，那么B根本不会受修改的影响。

对象“赋值”的时候情况发⽣了变化。

对⼀个对象进⾏操作时，我们真正操作的是它的句柄。

所以倘若“从⼀个对象到另⼀个对象”赋值，实际就是将句柄从⼀个地⽅复制到另⼀个地⽅。

这意味着假若为对象使⽤“C=D”，那么C和D最终都会指向最初只有D才指向的那个对象。

short s1 = 1; s1 = s1 + 1; （s1+1运算结果是int型，需要强制转换类型）short s1 = 1; s1 += 1;（可以正确编译） +=运算符⽆类型转换问题（2）算术运算符Java的算术运算符：加号（+）、减号（-）、除号（/）、乘号（*）以及模数（%，从整数除法中获得余数）。

整数除法会直接砍掉⼩数，⽽不是进位。

（3）⾃动递增、递减对于前递增和前递减（如++A或--A），会先执⾏运算，再⽣成值。

java运算符优先级规则

java运算符优先级规则Java运算符优先级规则是指在一个表达式中有多个运算符时，Java程序会按照一定的规则来确定运算符的优先级和结合性，以确保表达式得到正确的计算结果。

Java中的运算符优先级从高到低的顺序如下：1. ()：括号中的表达式优先级最高，先计算括号中的表达式。

2. ++,--：自增、自减运算符优先级次之，先执行自增、自减运算。

3. !：逻辑非运算符优先级次之，先执行逻辑非运算。

4. *,/,%,：乘、除、取模运算符优先级相同，先执行乘、除、取模运算。

5. +,-：加、减运算符优先级相同，先执行加、减运算。

6. <<,>>：位移运算符优先级相同，先执行位移运算。

7. <,<=,>,>=：比较运算符优先级相同，先执行比较运算。

8. ==,!=：相等、不相等运算符优先级相同，先执行相等、不相等运算。

9. &,|,^：位与、位或、位异或运算符优先级相同，先执行位运算。

10. &&,||：逻辑与、逻辑或运算符优先级相同，先执行逻辑运算。

11. =,+=,-=,*=,/=,%=,<<=,>>=,&=,|=,^=：赋值运算符优先级最低，先执行赋值运算。

值得注意的是，如果在一个表达式中有多个同级别的运算符，那么会根据其结合性来决定执行顺序。

Java中的运算符结合性分为左结合和右结合两种，左结合运算符从左往右依次执行，右结合运算符从右往左依次执行。

例如，a + b + c，加号运算符是左结合的，所以先执行 a + b，然后再加上 c 的值。

另外，如果表达式中有多个不同优先级的运算符，那么Java会首先计算优先级高的运算符，然后再计算优先级低的运算符。

如果要改变运算符优先级和结合性的默认规则，可以通过添加括号来强制改变运算符的执行顺序。

Java中的的运算符

Java中的的运算符一.运算符的优先级1：java语言中各运算符优先级如下所示（优先级从上到下依次递减）类型运算符单操作数运算符++ 、-- 、+ 、- 、！、~、（）算术运算符* 、/ 、% 、+ 、-移位运算符<< 、>> 、>>>比较运算符< <= > >= == != instanceof按位运算符& ^ |逻辑运算符&& ||条件运算符?:赋值运算符=2：java语言规定，表达式中运算顺序从左到右，但赋值顺序从右到左。

二.单操作数运算符1:单操作符不象大多数具有两个操作数的运算符,它只有一个操作数.java语言共提供了7种单操作运算符,分别是:自动递增运算符(++)自动递减运算符(--)取正运算符(+)取负运算符(-)按位取反运算符(~)逻辑取反运算符(!)造型运算符()2:自动递增运算指造作数加1运算.根据自动递增运算符和操作数位置关系,又分为前自动递增运算和后自动递增运算.前自动递增运算指运算符位于操作数之前,后自动递增运算指运算符位于操作数的后面.3:前自动递增运算和后自动递增运算对于操作数的改变是一样的，在原有值上均加1。

如果自动递增运算表达式位于表达式中，则前自动递增运算和后自动递增运算的意义就不同了。

前自动递增运算意味着先执行递增运算，后生成表达式值；后自动递增运算意味着先生成表达式值，后执行递增运算；4：--操作，同++。

5：按位取反运算~对一个整数型操作数进行按位操作，生成与输入位的相反值。

若输入0，则输出为1；若输入1，则输出0。

5：逻辑取反运算！对一个布尔型操作数进行操作，生成与输入位的相反值。

若输入为true,则输出为false;若输入为false，则输出为true;6：造型运算（）的作用是明确将一种数据类型转换为另一种数据类型，可能造成数据信息的丢失。

在java中，合法的类型转换编译器会自动进行，只有强制类型转换时，程序员才有必要进行造型运算。

Java中的表达式有哪些？

Java中的表达式有哪些？
Java语言的表达式和C语言非常类似。

本文是关于Java中的表达式的内容，下面是详细介绍。

运算符运算符(operator)优先级从高到底排列如下：.[]()++--!～
instanceof*/%+-;>;>;>;>;;;\==!=&结果会是int。

如果结果超过该类型的取值范围，则按该类型的最大值取模。

单目整数运算符是：
运算符操作-单目非～位补码++加1--减1
++运算符用于表示直接加1操作。

增量操作也可以用加运算符和赋值操作间接完成。

++lvalue(左值?copy;表示lvalue+=1,++lvalue也表示
lvalue=lvalue+1(只要lvalue没有副作用)。

--运算符用于表示减1操作。

++和--运算符既可以作为前缀运算符，也可以做为后缀运算符。

双目整数运算符是：
运算符操=，和/=。

此外，还有取模运算：%和%=也可以作用于浮点数，例如：a%b和a-((int)(a/b)*b)的语义相同。

这表示a%b的结果是除完后剩下的浮点数部分。

只有单精度操作数的浮点表达式按照单精度运算求值，产生单精度结果。

如果浮点表达式中含有一个或一个以上的双精度操作数，则按双精度运算，结果是双精度浮点数。

数组运算符数组运算符形式如下：[]可给出数组中某个元素的值。

合法的。

Java赋值运算符、条件运算符及运算符的优先级

Java赋值运算符、条件运算符及运算符的优先级赋值运算符赋值运算符可以和许多运算符组合构成复杂的运算符，这种运算符是先进⾏相应的运算，然后再把运算结果赋值给赋值运算符左侧的变量。

double a = 10;double b = 20;a /= b;System.out.println(a);0.5字符串连接符'+'当输出⾥'+'出现了String类型（""）,String右侧的数据转成String类型进⾏连接int c = 10;int d = 20;System.out.println(""+c+d);System.out.println(c+d+""); //字符串左侧不会进⾏转换102030条件运算符条件运算符是唯⼀的⼀个三⽬运算符，包含3个操作对象，其语法表达式如下：条件表达式 ? 值1 : 值2;根据 ? 的左侧条件表达式的值来判断整个表达式的值。

如果条件表达式的值为真（true），则取值1，条件表达式为假（false），则取值2。

int socre = 59;String type = socre > 60?"及格":"不及格";System.out.println(type);不及格运算符的优先级运算符的优先级决定了表达式中运算符执⾏的先后顺序，通过改变运算符的结合⽅向和使⽤括号'()'可以改变执⾏的顺序。

⼀般来说，编写程序时不需要去记忆运算符的优先级。

对于不清楚优先级的地⽅，最好使⽤⼩括号进⾏划分。

编写程序时，除了要让⾃⼰看的懂外，有时还需要给团队的成员或项⽬负责⼈阅读，所以⼀个良好的程序书写规则会让⾃⼰的程序更好地被理解与维护。

Java运算符的优先级+三元运算符+偷懒用法

Java运算符的优先级+三元运算符+偷懒⽤法Java运算符的优先级优先级运算符结合性1()、[]、{}从左向右2!、+、-、~、++、--从右向左3*、/、%从左向右4+、-从左向右5«、»、>>>从左向右6<、<=、>、>=、instanceof从左向右7==、!=从左向右8&从左向右9^从左向右10|从左向右11&&从左向右12||从左向右13?:从右向左14=、+=、-=、*=、/=、&=、|=、^=、~=、«=、»=、>>>=从右向左偷懒⽤法package operator;public class Demo07 {public static void main(String[] args) {int a = 10;int b = 20;a+=b;//偷懒⽤法 a = a + ba-=b;//偷懒⽤法 a = a - bSystem.out.println(a);//字符串连接符 + , StringSystem.out.println(a+b);System.out.println(""+a+b);//字符串在前，后边的都拼接System.out.println(a+b+"");//字符串在后，前⾯的正常运算}}三元运算符必须掌握package operator;//三元运算符public class Demo08 {public static void main(String[] args) {//x ? y : z//如果x为true ，则结果为y ，否则结果为zint score = 95;String type = score < 60 ? "不合格" : "合格"; //必须掌握System.out.println(type);}}写完去看 alibaba开发⼿册。

Java中运算符的先后顺序

Java中运算符的先后顺序
单⽬>算数运算符>移位>⽐较>按位>逻辑>三⽬>赋值
单⽬运算符（⼀元运算符，即⼀个变量）：+，-，++，--
算数运算符：+，-，*，/，%
移位运算符：<<,>>
关系运算符：>,<,>=,<=,==,!=
位运算符：&，|，~，^,
逻辑运算符：&&，||
三⽬运算符：表达式1？表达式2：表达式3;
赋值运算符：=等
位运算符主要针对⼆进制，它包括了：“与”、“⾮”、“或”、“异或”。

从表⾯上看似乎有点像逻辑运算符，但逻辑运算符是针对两个关系运算符来进⾏逻辑运算，⽽位运算符主要针对两个⼆进制数的位进⾏逻辑运算
int a=129;
int b=128;
int c=a&b;
“a”的值是129，转换成⼆进制就是10000001，⽽“b”的值是128，转换成⼆进制就是10000000。

根据与运算符的运算规律，只有两个位都是1，结果才是1，可以知道结果就是10000000，即128
位运算与逻辑运算的区别：
（|）和（||）成⽴的条件是只要⼀侧表达式为真，结果就为真，在（|）运算时，⽆论左侧的表达式的值为真还是为假，都要判断右侧的表达式的值的真假，⽽（||）在运算时，只要左侧表达式的值为真，就不再判断右侧表达式的值了。

Java运算符

Java运算符1. 运算符（Operator）运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

运算符的分类：•按照功能分为：算术运算符、赋值运算符、比较(或关系)运算符、逻辑运算符、位运算符、条件运算符、Lambda运算符。

•按照操作数个数分为：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符（三目运算符）。

1.1 算术运算符1.1.1 基本语法举例1：加减乘除模举例2：“+”号的两种用法•第一种：对于+两边都是数值的话，+就是加法的意思•第二种：对于+两边至少有一边是字符串的话，+就是拼接的意思举例3：自加自减运算理解：++ 运算，表示自增1。

同理，-- 运算，表示自减1，用法与++ 一致。

1、单独使用•变量在单独运算的时候，变量前++和变量后++，是没有区别的。

•变量前++ ：例如 ++a 。

•变量后++ ：例如 a++ 。

2、复合使用•和其他变量放在一起使用或者和输出语句放在一起使用，前++和后++就产生了不同。

•变量前++ ：变量先自增1，然后再运算。

•变量后++ ：变量先运算，然后再自增1。

1.1.2 案例与练习案例1：随意给出一个整数，打印显示它的个位数，十位数，百位数的值。

格式如下：数字xxx的情况如下：个位数：十位数：百位数：例如：数字153的情况如下：个位数：3十位数：5百位数：1拓展：获取一个四位数的个位，十位，百位，千位案例2：为抵抗洪水，战士连续作战89小时，编程计算共多少天零多少小时？练习1：算术运算符：自加、自减练习2：练习3：练习4：练习5：（企业真题）写出下列程序的输出结果1.2 赋值运算符1.2.1 基本语法•符号：=o当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。

o支持连续赋值。

•扩展赋值运算符： += -= *= /= %=1.2.2 练习练习1：练习2：练习3：练习4：练习5：你有几种办法实现变量值减1？变量值减2呢？1.3 比较(关系)运算符•比较运算符的结果都是boolean型，也就是要么是true，要么是false。

Java初级学习（四）Java运算符

Java初级学习（四）Java运算符1.Java运算符*运算符的优先级要求：多⽤()，提⾼代码可读性，不要只依靠运算符的优先级，也不⽤刻意去记。

算术运算符：+ - * / %（取余） ++ --赋值运算符：=关系运算符：> < >= <= == !=（不等于） instanceof ========》这⾥结果是true或false 逻辑运算符：&&（与and，只有左右都为true时结果才为true） ||（或or） !（⾮no）位运算符：条件运算符：? :1）算数运算符（1）%：11除以5等于2余1，也就是 11%5=1（2）++ --前缀⾃增⾃减法(++i,--i): 先进⾏⾃增或者⾃减运算，再进⾏表达式运算。

　*执⾏⼀次 i++ 或者 ++i 就等于执⾏⼀次 i=i+1 这条命令。

同理，执⾏⼀次 i-- 或者 --i 就等于执⾏⼀次 i=i-1 这条命令。

后缀⾃增⾃减法(i++,i--): 先进⾏表达式运算，再进⾏⾃增或者⾃减运算。

1public class Demo04 {2public static void main(String[] args){34int i = 2;//定义⼀个变量5//i=i+1;下⾯⼀⾏的++i，就相当于在执⾏给b赋值之前，先执⾏⼀遍i=i+1。

6int a = ++i;//先运⾏i=i+1,再给b赋值。

7int b = i++;8//i=i+1;上⾯⼀⾏的++i，就相当于在执⾏给b赋值之后，再执⾏⼀遍i=i+1。

9 System.out.println(a);10 System.out.println("现在i为"+i); //这⾥i=3，因为上⾯有个++i11 System.out.println("=====================");1213//前缀⾃增⾃减,先进⾏⾃增⾃减，再进⾏表达式14int b1=2*++i; //2*(i+1)=815 System.out.println("现在i为"+i); //这⾥i=4，因为上⾯有两个++i16int c1=2*--i; //2*(i-1)=617 System.out.println("现在i为"+i); //这⾥i=3，因为上⾯有个--i1819//后缀⾃增⾃减，先进⾏表达式，在进⾏⾃增⾃减。

Java中的运算符和各种运算符的优先级和结合性及注意事项整理

Java中的运算符和各种运算符的优先级和结合性及注意事项整理（1）算术运算符Java运算符算术运算符代数表达式Java表达式加+a+1a+1减-a-b a-b乘*ab a*b除/a/b a/b求模/余% a mod b a%b注意：1>Java 中没有求幂的算术运算符2>Java 中没有表⽰指数运算的运算符（2）等式和关系运算符代数等式和关系运算符Java等式或关系运算符Java条件表达式⽰例Java条件表达式含义等式运算符===a==b a等于b≠！=a！=b a不等于b关系运算符>>a>b a⼤于b<<a<b a⼩于b≥>=a>=b a⼤于等于b≤<=a<=b a⼩于等于b注意：1>不能将相等运算符“==”与赋值运算符“=”混为⼀谈，会导致逻辑错误或者语法错误。

2>由两个符号组成的运算符中，两个符号之间不能出现空格，否则，将会产⽣语法错误。

（3）复合赋值运算符Java中提供了⼏个复合赋值运算符，⽤以简化赋值运算表达式。

任何⼀种类似于下⾯形式的表达式：变量 = 变量运算符表达式；其中，运算符可以是⼆元运算符+，-，*，/和%以及其它运算符中的某⼀个，都可以转换成下⾯这种形式：变量运算符 = 表达式；例，下⾯为算术赋值运算符赋值运算符⽰例表达式说明赋值操作+= c = 3,c += 7 c = c + 7将10赋给c-= d = 5,d -= 4 d = d - 4将1赋给d*= e = 4,e *= 5 e = e * 5将20赋给e/= f = 6,f /= 3 f = f / 3将2赋给f%=g = 12,g %= 9g = g % 9将3赋给g（4）⾃增和⾃减运算符Java提供了两个⼀元运算符⼀元⾃增运算符“++”和⼀元⾃减运算符“--”，⽤于在⼀个数字变量上加1和减1。

⾃增（或⾃减）运算符放在变量的前⾯，相应的称之为前⾃增（或前⾃减）运算符。

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：java语言中各运算符优先级如下所示（优先级从上到下依次递减）类型运算符单操作数运算符++ 、-- 、+ 、- 、！、~、（）算术运算符* 、/ 、% 、+ 、-移位运算符<<、>>、>>>比较运算符<<= >>= == != instanceof按位运算符& ^ |逻辑运算符&& ||条件运算符?:赋值运算符=2：java语言规定，表达式中运算顺序从左到右，但赋值顺序从右到左。

二.单操作数运算符1:单操作符不象大多数具有两个操作数的运算符,它只有一个操作数.java语言共提供了7种单操作运算符,分别是:自动递增运算符(++)自动递减运算符(--)取正运算符(+)取负运算符(-)按位取反运算符(~)逻辑取反运算符(!)造型运算符()2:自动递增运算指造作数加1运算.根据自动递增运算符和操作数位臵关系,又分为前自动递增运算和后自动递增运算.前自动递增运算指运算符位于操作数之前,后自动递增运算指运算符位于操作数的后面.3:前自动递增运算和后自动递增运算对于操作数的改变是一样的，在原有值上均加1。

如果自动递增运算表达式位于表达式中，则前自动递增运算和后自动递增运算的意义就不同了。

前自动递增运算意味着先执行递增运算，后生成表达式值；后自动递增运算意味着先生成表达式值，后执行递增运算；4：--操作，同++。

5：按位取反运算~对一个整数型操作数进行按位操作，生成与输入位的相反值。

若输入0，则输出为1；若输入1，则输出0。

5：逻辑取反运算！对一个布尔型操作数进行操作，生成与输入位的相反值。

在java中，合法的类型转换编译器会自动进行，只有强制类型转换时，程序员才有必要进行造型运算。

Java运算符+(优先级、目数)+

说明：1.算术运算符+ :加法- ：减法* ：乘法/ ：除法% ：取余运算2.关系运算符< ：只能比较基本类型数据之间的关系，不能比较对象之间的关系。

> : (同关系运算符“<”)<=: (同关系运算符“<”)>=: (同关系运算符“<”)== ：若使用该运算符比较两个对象的引用（变量），则实质上是比较两个变量是否引用了相同的对象。

所谓相同的对象是指，是否是在堆栈（Heap）中开辟的同一块儿内存单元中存放的对象。

若比较两个对象的引用(变量)所引用的对象的内容是否相同，则应该使用equals()方法，该方法的返回值类型是布尔值。

需要注意的是：若用类库中的类创建对象，则对象的引用调用equals()方法比较的是对象的内容；若用自定义的类来创建对象，则对象的引用调用equals()方法比较的是两个引用是否引用了同一个对象，因为第二种情况equals()方法默认的是比较引用。

!= ：(同关系运算符“==”)3.逻辑运算符（操作符只能是布尔类型的）&&||!4.位运算符&|^! ：不可以与=联用，因为!是一元操作符；不可以对布尔类型的数据进行按位非运算5.移位运算符（只能处理整数运算符）Char、byte、short类型，在进行移位之前，都将被转换成int类型，移位后的结果也是int类型；移位符号右边的操作数只截取其二进制的后5位（目的是防止因为移位操作而超出int类型的表示范围：2的5次方是32，int类型的最大范围是32位）；对long类型进行移位，结果仍然是long类型，移位符号右边的操作符只截取其二进制的后6位。

<< ：>> ：若符号位为正，则在最高位插入0；若符号位为负，则在最高位插入1>>> ：无论正负，都在最高位插入0。

Java里的常用运算符及其优先级顺序

Java⾥的常⽤运算符及其优先级顺序
知道了⼋种基本数据类型后，在使⽤中弄清运算符的优先级是很有必要的。

具体如下图：
这⾥需要注意的是，强制类型转换的优先级是位于乘除前⾯⽽处于单⽬运算符后⾯的，这是⽐较容易出错的地⽅。

⽐如⽤Math.Random（）获取5个10以内的整数。

采⽤如下代码：
1int[] a=new int[5];
2for(int i=0;i<5;i++)
3 {
4 a[i]=(int)Math.random()*10;
5 }
6 System.out.println(Arrays.toString(a));
这时控制台上会输出5个0，这是因为强制类型转换的优先级是⽐乘除⾼的，先向下取整然后进⾏乘除运算。

另外还需要注意⾃增⾃减运算符的“前缀”和“后缀”形式，赋值或输出时结果是不同的，如：
int a=0;
int b=0;
System.out.println(a++);
System.out.println(++b);
输出结果为0,1；这说明“后缀”形式是先赋值然后才进⾏⾃增操作的，⽽“前缀”形式是先⾃增操作，⽽后赋值的。