常用运算符
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。Java也提供了一套丰富的运算符来操纵变量，们可以把运算符分成以下几组：
算术运算符、关系运算符、位运算符、逻辑运算符、赋值运算符 和 其他运算符
算数运算符
算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。下表列出了所有的算术运算符。表格中的实例假设整数变量A的值为10，变量B的值为20：
| 操作符 | 描述 | 例子 |
|---|---|---|
| + | 加法 - 相加运算符两侧的值 | A + B 等于 30 |
| - | 减法 - 左操作数减去右操作数 | A – B 等于 -10 |
| * | 乘法 - 相乘操作符两侧的值 | A * B等于200 |
| / | 除法 - 左操作数除以右操作数 | B / A等于2 |
| ％ | 取余 - 左操作数除以右操作数的余数 | B%A等于0 |
| ++ | 自增: 操作数的值增加1 | B++ 或 ++B 等于 21 |
| -- | 自减: 操作数的值减少1 | B-- 或 --B 等于 19 |
自增自减运算符
自增（++）自减（--）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数。
前缀自增自减法(++a,--a): 先进行自增或者自减运算，再进行表达式运算。
后缀自增自减法(a++,a--): 先进行表达式运算，再进行自增或者自减运算 实例：
public class Test {
public static void main(String[] args){
int a = 5;//定义一个变量；
int b = 5;
// 拆分运算过程为: a=a+1=6; x=2*a=12
int x = 2*++a;
// 拆分运算过程为: y=2*b=2*5=10; b=b+1=6
int y = 2*b++;
System.out.println("a="+a+",x="+x); // a=6, x=12
System.out.println("b="+b+",y="+y); // b=6, y=10
}
}
关系运算符
下表为Java支持的关系运算符。表格中的实例整数变量A的值为10，变量B的值为20：
| 运算符 | 描述 | 例子 |
|---|---|---|
| == | 检查如果两个操作数的值是否相等，如果相等则条件为真。 | （A == B）为假(非真)。 |
| != | 检查如果两个操作数的值是否相等，如果值不相等则条件为真。 | (A != B) 为真。 |
| > | 检查左操作数的值是否大于右操作数的值，如果是那么条件为真。 | （A> B）非真。 |
| < | 检查左操作数的值是否小于右操作数的值，如果是那么条件为真。 | （A <B）为真。 |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。 | （A> = B）为假。 |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。 | （A <= B）为真。 |
public class Test {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("a==b : " + (a == b) ); // a==b : false
System.out.println("a!=b : " + (a != b) ); // a!=b : true
System.out.println("a>b : " + (a > b) ); // a>b : false
System.out.println("a<b : " + (a < b) ); // a<b : true
System.out.println("b>=a : " + (b >= a) ); // b>=a : true
System.out.println("b<=a : " + (b <= a) ); // b<=a : false
}
}
位运算符
Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。位运算符作用在所有的位上，并且按位运算。
下表列出了位运算符的基本运算，假设整数变量A的值为60（二进制：0011 1100）和变量B的值为13（0000 1101）：
| 操作符 | 描述 | 例子 |
|---|---|---|
| ＆ | 如果相对应位都是1，则结果为1，否则为0 | （A＆B），得到12，即0000 1100 |
| | | 如果相对应位都是0，则结果为0，否则为1 | （A | B）得到61，即 0011 1101 |
| ^ | 如果相对应位值相同，则结果为0，否则为1 | （A ^ B）得到49，即 0011 0001 |
| 〜 | 按位取反运算符翻转操作数的每一位，即0变成1，1变成0。 | （〜A）得到-61，即1100 0011 |
| << | 按位左移运算符。左操作数按位左移右操作数指定的位数。 | A << 2得到240，即 1111 0000 |
| >> | 按位右移运算符。左操作数按位右移右操作数指定的位数。 | A >> 2得到15即 1111 |
| >>> |
按位右移补零操作符。 左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。 | A>>>2得到15即0000 1111 |
位运算&、|、^
public class Test {
public static void main(String[] args) {
int x = 3 ;
// 3的二进制数据：00000000 00000000 00000000 00000011
int y = 6 ;
// 6的二进制数据：00000000 00000000 00000000 00000110
System.out.println(x & y); // 2
// 与操作的结果： 00000000 00000000 00000000 00000010
System.out.println(x | y); // 7
// 或操作的结果： 00000000 00000000 00000000 00000111
System.out.println(x ^ y); // 5
// 异或操作结果： 00000000 00000000 00000000 00000101
}
}
求负数的反码：
public class Test {
public static void main(String[] args) {
int x = -3 ; // -3的二进制数据：11111111 11111111 11111111 11111101
System.out.println(x + "的反码是：" + ~x); // -3的反码是：2
}
}
左移操作<<：
左移操作是将运算数的二进制码整体左移指定位数，左移之后的空位使用0来填充。
public class Test {
public static void main(String[] args) {
int x = 3 ;
// 3的二进制数据：00000000 00000000 00000000 00000011
System.out.println(x + "左移2位之后的内容：" + (x << 2)); // 12
}
}
右移操作（带符号）>>
public class Test {
public static void main(String[] args) {
int x = 3 ;
// 3的二进制数据：00000000 00000000 00000000 00000011
int y = -3 ;
// -3的二进制数据：11111111 11111111 11111111 11111101
System.out.println(x + "右移2位之后的内容：" + (x >> 2)); // 0
System.out.println(y + "右移2位之后的内容：" + (y >> 2)); // -1
}
}
无符号右移>>>
使用此操作将以“0”填充空出来的位
public class Test {
public static void main(String[] args) {
int x = 3 ;
// 3的二进制数据：00000000 00000000 00000000 00000011
int y = -3 ;
// -3的二进制数据：11111111 11111111 11111111 11111101
System.out.println(x + "右移2位之后的内容：" + (x >>> 2)); // 0
System.out.println(y + "右移2位之后的内容：" + (y >>> 2)); // 1073741823
}
}
逻辑运算符
下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假。
| 操作符 | 描述 | 例子 |
|---|---|---|
| && | 称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。 | （A && B）为假。 |
| | | | 称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。 | （A | | B）为真。 |
| ！ |
称为逻辑非运算符。用来反转操作数的逻辑状态。 如果条件为true，则逻辑非运算符将得到false。 | ！（A && B）为真。 |
public class Test {
public static void main(String[] args) {
boolean a = true;
boolean b = false;
System.out.println("a && b = " + (a&&b)); // false
System.out.println("a || b = " + (a||b) ); // true
System.out.println("!(a && b) = " + !(a && b)); // true
}
}
短路逻辑运算符
当使用与逻辑运算符时，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。
public class Test {
public static void main(String[] args){
int a = 5;//定义一个变量；
// 首先判断 a<4 的结果为 false，则 b 的结果必定是 false，
// 所以不再执行第二个操作 a++<10 的判断，所以 a 的值为 5。
boolean b = (a<4) && (a++<10);
System.out.println("使用短路逻辑运算符的结果为"+b); // false
System.out.println("a的结果为"+a); // 5
}
}
赋值运算符
下面是Java语言支持的赋值运算符：
| 操作符 | 描述 | 例子 |
|---|---|---|
| = | 简单的赋值运算符，将右操作数的值赋给左侧操作数 | C = A + B将把A + B得到的值赋给C |
| + = | 加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数 | C + = A等价于C = C + A |
| - = | 减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数 | C - = A等价于C = C - A |
| * = | 乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数 | C * = A等价于C = C * A |
| / = | 除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数 | C / = A等价于C = C / A |
| （％）= | 取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数 | C％= A等价于C = C％A |
| << = | 左移位赋值运算符 | C << = 2等价于C = C << 2 |
| >> = | 右移位赋值运算符 | C >> = 2等价于C = C >> 2 |
| ＆= | 按位与赋值运算符 | C＆= 2等价于C = C＆2 |
| ^ = | 按位异或赋值操作符 | C ^ = 2等价于C = C ^ 2 |
| | = | 按位或赋值操作符 | C | = 2等价于C = C | 2 |
public class Test {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 0;
c = a + b; // 30
c += a ; // c = c+a = 30+10 = 40
c -= a ; // c = c-a = 40-10 = 30
c *= a ; // c = c*a = 30*10 = 300
c /= a ; // c = c/a = 300/10 = 30
c %= a ; // c= c%a = 30%10 = 0
a = 10;
c = 15;
c /= a ; // c = c/a = 15/10 = 1
a = 10;
c = 15;
c %= a ; // c = c%a = 15%10 = 5
c <<= 2 ; // c = c<<2 = 5<<2 = 20
c >>= 2 ; // c = c>>2 = 20>>2 = 5
c >>= 2 ; // c = c>>2 = 5>>2 = 1
c &= a ; // c = c&a = 1&10 = (00000001 & 00001010=00000000) = 0
c ^= a ; // c = c^a = 0^10 = (00000000 ^ 00001010=00001010) = 10
c |= a ; // c = c|a = 10|10 = (00001010 | 00001010=00000000) = 0
}
}
条件运算符
条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。
三元运算符格式：(关系表达式)？表达式1：表达式2
public class Test {
public static void main(String[] args){
int a , b;
a = 10;
// 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
b = (a == 1) ? 20 : 30;
System.out.println( "Value of b is : " + b ); // 30
// 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
b = (a == 10) ? 20 : 30;
System.out.println( "Value of b is : " + b ); // 20
}
}
instanceof 运算符
该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。instanceof运算符使用格式：
( Object reference variable ) instanceof (class/interface type)
如果运算符左侧变量所指的对象，是操作符右侧类或接口(class/interface)的一个对象，那么结果为真。
String str= "zwj";
boolean result = str instanceof String; // 由于 str是 String 类型，所以返回true
如果被比较的对象兼容于右侧类型，该运算符仍然返回true。
class Vehicle {}
public class Car extends Vehicle {
public static void main(String[] args){
Vehicle a = new Car();
boolean result = a instanceof Car;
System.out.println( result); // true
}
}
Java运算符优先级
当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中，运算符优先级不同会导致最后得出的结果差别甚大。下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。
| 类别 | 操作符 | 关联性 |
| 后缀 | () [] . (点操作符) | 左到右 |
| 一元 | + + - ！〜 | 从右到左 |
| 乘性 | * /％ | 左到右 |
| 加性 | + - | 左到右 |
| 移位 | >> >>> << | 左到右 |
| 关系 | >> = << = | 左到右 |
| 相等 | == != | 左到右 |
| 按位与 | ＆ | 左到右 |
| 按位异或 | ^ | 左到右 |
| 按位或 | | | 左到右 |
| 逻辑与 | && | 左到右 |
| 逻辑或 | | | | 左到右 |
| 条件 | ？： | 从右到左 |
| 赋值 | = + = - = * = / =％= >> = << =＆= ^ = | = | 从右到左 |
| 逗号 | ， | 左到右 |
注意：
1）任何整数模2不是0就是1，所以只要改变被模数就可以实现开关运算。
2）逻辑运算符除了 ! 外都是用于连接两个boolean类型表达式。
3）如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。 但被模数是负数则不可忽略。此外，取模运算的结果不一定总是整数。
4）对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
5） “+”除字符串相加功能外，还能把非字符串转换成字符串。
6）当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。支持连续赋值。
7）三元运算符可简化if-else语句，三元运算符要求必须返回一个结果。
8）只有单目运算符、三元运算符、赋值运算符是从右向左运算的。
9）2 << 3 是算出2乘以8的最有效率的方法。
10）无符号右移时在最高位添零。
11）Java使用补码表示二进制数。
二、表达式
Java中的语句有很多种形式，表达式就是其中一种形式。表达式由操作数与运算符所组成。
操作数可以是常量、变量，也可以是方法；运算符就是数学中的运算符号如“+”、“-”、“*”、“/”、“%”等。以下面的表达式（z+100）为例，“z”与“100”都是操作数，而“+”就是运算符。
表达式的计算结果必须是一个值，如果表达式是一个条件，就会产生逻辑值结果，即真或假。在其他情况下，值通常为计算的结果。
扫一扫
6390
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
