算术操作符
操作符 | 名称 | 描述 |
+ | 加 | 加法运算 |
- | 减 | 加法运算 |
* | 乘 | 乘法运算 |
/ | 除 | 除法运算 |
% | 模 | 模运算(取余数) |
++ | 自增 | 自身+1 (例如 B++(后自增) 或 ++B (前自增)) |
-- | 自减 | 自身减1 (B-- (后自减) 或 --B (前自减)) |
public class Test {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 25;
int d = 25;
System.out.println("a + b = " + (a + b) );
System.out.println("a - b = " + (a - b) );
System.out.println("a * b = " + (a * b) );
System.out.println("b / a = " + (b / a) );
System.out.println("b % a = " + (b % a) );
System.out.println("c % a = " + (c % a) );
System.out.println("a++ = " + (a++) );
System.out.println("a-- = " + (a--) );
System.out.println("d++ = " + (d++) );
System.out.println("++d = " + (++d) );
}
}
运行结果:
a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
a++ = 10
a-- = 11
d++ = 25
++d = 27
关系操作符
操作符 | 名称 | 描述 |
== | 等于 | 左右两个操作数的值是否相等,如果相等,那么条件为真,否则为假。 |
!= | 不等于 | 左右两个操作数的值是否不相等,如果不相等,那么条件为真,否则为假。 |
> | 大于 | 左操作数是否大于右操作数的值,如果大于,那么条件为真,否则为假。 |
< | 小于 | 左操作数是否小于右操作数的值,如果小于,那条件么为真,否则为假。 |
>= | 大于等于 | 左操作数是否大于或等于右操作数的值,如果大于或等于,那条件么为真,否则为假。 |
<= | 小于等于 | 左操作数是否小于或等于右操作数的值,如果小于或等于,那条件么为真,否则为假。 |
public class TestClass {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("a == b = " + (a == b) );
System.out.println("a != b = " + (a != b) );
System.out.println("a > b = " + (a > b) );
System.out.println("a < b = " + (a < b) );
System.out.println("b >= a = " + (b >= a) );
System.out.println("b <= a = " + (b <= a) );
}
}
运行结果:
a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false
位操作符
操作符 | 名称 | 描述 |
& | 与 | 两个操作数相对应的位都是1,则结果为1,否则为0 |
| | 或 | 两个操作数相对应的位都是 0,则结果为 0,否则为 1 |
^ | 异或 | 两个操作数相对应的位值相同,则结果为0,否则为1 |
~ | 非 | 反转操作数的64位值,如果位值为0,则反转为1,如果位值为1,则反转为0. |
<< | 左移 | 操作数的所有位值向左移动两位 |
>> | 右移 | 操作数的所有位值向右移动两位 |
>>> | 无符号右移 | 操作数按右移来操作,空白位以0来填补 |
public class TestClass {
public static void main(String[] args) {
int a = 60; /* 60 = 0011 1100 */
int b = 13; /* 13 = 0000 1101 */
int c = 0;
c = a & b; /* 12 = 0000 1100 */
System.out.println("a & b = " + c );
c = a | b; /* 61 = 0011 1101 */
System.out.println("a | b = " + c );
c = a ^ b; /* 49 = 0011 0001 */
System.out.println("a ^ b = " + c );
c = ~a; /*-61 = 1100 0011 */
System.out.println("~a = " + c );
c = a << 2; /* 240 = 1111 0000 */
System.out.println("a << 2 = " + c );
c = a >> 2; /* 15 = 1111 */
System.out.println("a >> 2 = " + c );
c = a >>> 2; /* 15 = 0000 1111 */
System.out.println("a >>> 2 = " + c );
}
}
&(与)纯手工计算如下:
a=60;//使用计算器转换成二进制如下:
b=13;//使用计算器转换成二进制如下:
根据&位运算的描述计算如下:
为什么结果为12呢?看图就明白了:
|(或)位运算手工计算如下:
^(异或)纯手工计算如下:
~(非)纯手工计算如下:
对比一下就明白它的原理了.所以~60之后的值为-61.
剩下的左移以及右移跟无符号右移都差不多是这样来计算.大家多动手练习一下.
逻辑操作符
操作符 | 名称 | 描述 |
&& | 逻辑且 | 比较左右操作数,如果两个操作数都为真,那么条件为真,否则为假. |
| | | 逻辑或 | 比较左右操作数,如果两个操作数有一个为真,那么条件为真,如果两个操作数都为假,那么条件为假. |
! | 逻辑非 | 如果操作数为真,那么条件为假,如果操作数为假,那么条件为真. |
public class TestClass {
public static void main(String[] args) {
boolean a = true;
boolean b = false;
System.out.println("a && b = " + (a&&b));
System.out.println("a || b = " + (a||b) );
System.out.println("!(a) = " + !(a));
}
}
运行结果:
a && b = false
a || b = true
!(a) = false
赋值操作符
操作符 | 名称 | 描述 |
= | 等于 | 将右操作数的值赋给左侧操作数 |
+= | 加等于 | 将左操作数和右操作数相加得到的值,赋值给左操作数 |
-= | 减等于 | 将左操作数和右操作数相减得到的值,赋值给左操作数 |
*= | 乘等于 | 将左操作数和右操作数相乘得到的值,赋值给左操作数 |
/= | 除等于 | 将左操作数和右操作数相除得到的值,赋值给左操作数 |
(%)= | 模等于 | 将左操作数和右操作数取模后得到的值,赋值给左操作数 |
<<= | 左移等于 | 右操作数左移位运算之后,赋值给左操作数 |
>>= | 右移等于 | 右操作数右移位运算之后,赋值给左操作数 |
&= | 位与等于 | 右操作数位与运算之后,赋值给左操作数 |
^= | 位异或等于 | 右操作数位异或运算之后,赋值给左操作数 |
|= | 位或等于 | 右操作数位或运算之后,赋值给左操作数 |
public class TestClass {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 0;
c = a + b;
System.out.println("c = a + b = " + c ); //C = A + B
c += a ;
System.out.println("c += a = " + c ); // C + = A 等同于 C = C + A
c -= a ;
System.out.println("c -= a = " + c ); //C - = A 等同于 C = C - A
c *= a ;
System.out.println("c *= a = " + c ); //C * = A 等同于 C = C * A
a = 10;
c = 15;
c /= a ;
System.out.println("c /= a = " + c ); //C / = A 等同于 C = C / A (同类型情况下)
a = 10;
c = 15;
c %= a ;
System.out.println("c %= a = " + c ); //C%= A 等同于 C = C%A
c <<= 2 ;
System.out.println("c <<= 2 = " + c ); //C << = 2 等同于 C = C << 2
c >>= 2 ;
System.out.println("c >>= 2 = " + c ); //C >> = 2 等同于 C = C >> 2
c &= a ;
System.out.println("c &= a = " + c ); //C&= 2 等同于 C = C&2
c ^= a ;
System.out.println("c ^= a = " + c ); //C ^ = 2 等同于 C = C ^ 2
c |= a ;
System.out.println("c |= a = " + c ); //C | = 2 等同于C = C | 2
}
}
运行结果:
c = a + b = 30
c += a = 40
c -= a = 30
c *= a = 300
c /= a = 1
c %= a = 5
c <<= 2 = 20
c >>= 2 = 5
c &= a = 0
c ^= a = 10
c |= a = 10
条件操作符 ?:
语法格式: (条件表达式)?值1:值2
描述:如果条件表达式为真,则取值1,否则取值2.
public class TestClass {
public static void main(String[] args){
int a , b;
a = 10;
b = (a == 1) ? 20 : 30; // 如果 a 等于 1 成立,则把b 赋值为 20,否则为 30
System.out.println( "Value of b is : " + b );
b = (a == 10) ? 20 : 30; // 如果 a 等于 10 成立,则把 b 赋值为 20,否则为 30
System.out.println( "Value of b is : " + b );
}
}
instanceof操作符
检查某个对象实例是否为指定的类型,如果是指定的类型则为真,否则为假.
例如:
最后说说操作符的优先级,这么多操作符,不同的优先级运算的结果是不一样的.我们可没有那么多时间以及精力去完完全全掌握他们的优先级,
所以这里有一个最简单的办法,就是使用"()"括号来表达他们的优先级,开发者想先运算哪里就用()括起来就行了,就是这么简单.