Java运算符
运算符
运算符就是在用变量或常量进行运算时，经常需要用到的符号，java目前常用的有以下几种：
1、算术运算符
2、赋值运算符
3、比较运算符
4、逻辑运算符
5、位运算符
6、三元运算符
7、转型运算符
8、逗号运算符
9、字符串运算符
一、算术运算符
运算符 运算 范例 结果
+ 正号 +3 3
- 负号 b=4;-b -4
+ 加 5+5 10
- 减 6-4 2
* 乘 3*4 12
/ 除 5/5 1
% 取模 5%5 0
++ 自增（前） a=2;b=++a a=3;b=3 ++在前，先加后用
++ 自增（后） a=2;b=a++ a=3;b=2 ++在后，先用后加
-- 自减（前） a=2;b=--a a=1;b=1 --在前，先减后用
-- 自减（后） a=2;b=a-- a=1;b=2 --在后，先用后减
+ 字符串相加 "He"+"llo" "Hello"
两个数相除的余数是多少，用%（取模）运算
规则：
左边<右边，结果=左边
左边=右边，结果=0
右边=1 ，结果=0
实例：
System.out.println(323%9);
//定义两个变量名a和b，a被赋值3，b没有被赋值
int a = 3,b;
//++给a这个变量中的值进行一次+1操作，并把+1操作后的值重新赋给a
//a++ 等于 a = a+1;
b = a++; //运算顺序：先把a的值赋给b，然后a再自增
//b = ++a; //运算顺序：a的值先自增，然后再赋给b
System.out.println(a);
System.out.println(b);
二、赋值运算符
符号 描述
= 将右边的值或者变量的值赋给左边的变量
+= 将左边加上右边再将结果赋给左边
-= 将左边减去右边再将结果赋给左边
*= 将左边乘以右边再将结果赋给左边
/= 将左边除以右边再将结果赋给左边
%= 将左边模以右边再将结果赋给左边
示例：
int a,b,c;a=b=c=3;
int a = 3; a+=5; 同等算法a=a+5;
思考
short s = 3；
s=s+2；
s+=2
有什么区别？
s=s+2; //编译失败，因为s会被提升为int类型，运算后的结果还是int类型，无法赋值给short类型。
s+=2; //编译通过，因为+=运算符在给s赋值时，自动完成了强转操作。
实例：
//定义一个变量，初始化值为5
int x = 5;
//注意：下面的各条打印语句都要单独执行。
//System.out.println(x = 2);//2
//System.out.println(x += 2);//7
//System.out.println(x -= 2);//3
//System.out.println(x *= 2);//10
//System.out.println(x /= 2);//2
System.out.println(x %= 2);//1
三、比较运算符
运算符 运算 范例 结果
== 相等于 4==3 false
!= 不等于 4!=3 true
< 小 4<3 false
> 大于 4>3 true
<= 小于等于 4<=3 false
>= 大于等于 4>=3 true
注：
比较运算符的结果都是boolean型，要么是true，要么是false。
比较运算符"=="不能写成"=",如3=4是错误的，正确是3==4
实例：
int x = 5;
int y = 2;
System.out.println(x == y);//false
System.out.println(x != y);//true
System.out.println(x < y);//false
System.out.println(x > y);//true
System.out.println(x <= y);//false
System.out.println(x >= y);//true
四、逻辑运算符
逻辑运算符用于连接boolean类型的表达式。
运算符 运算 范例 结果
& and(与) false&true false
| or(或) false|true true
&& and(短路) false&&true false
|| or(短路) false||true true
^ xor(异或) true^false true
! not(非) !true false
1、&与
true & true = true
true & false = false
false & true = false
false & false = false
结论:
其中有一边为false，结果 false
只要两边都为true，结果 true
实例：
int a = 2;
System.out.println(a<3 & a<6); //结果 true
System.out.println(a<3 & a>6); //结果 false
System.out.println(a>3 & a<6); //结果 false
System.out.println(a>3 & a>6); //结果 false
2、|或
true | true = true
true | false = true
false | true = true
false | false = false
结论：
其中有一边为true时，结果true
两边都为false时，结果false
实例：
int a = 2;
System.out.println(a<3 | a<6); //结果 true
System.out.println(a<3 | a>6); //结果 true
System.out.println(a>3 | a<6); //结果 true
System.out.println(a>3 | a>6); //结果 false
3、&&与（短路）
true && true = true
true && false = false
false && true = false
false && false = false
结论：
如果左边为false，结果false
如果两边都为 true，结果 true
实例：
int a = 2;
System.out.println(a<3 && a<6); //结果 true
System.out.println(a<3 && a>6); //结果 false
System.out.println(a>3 && a<6); //结果 false
System.out.println(a>3 && a>6); //结果 false
4、||或
true || true = true
true || false = true
false || true = true
false || false = false
结论：
两边只要有一个为true，结果为true。
只要两边都为false，结果为false。
实例：
int a = 2;
System.out.println(a<3 || a<6); //结果 true
System.out.println(a<3 || a>6); //结果 true
System.out.println(a>3 || a<6); //结果 true
System.out.println(a>3 || a>6); //结果 false
5、^异或
和|有点不一样，当true ^ true = false;
true ^ true = false
true ^ false = true
false ^ true = true
false ^ false = false
结论：
两边相同结果是false
两边不同结果是true
实例：
int a = 2;
System.out.println(a<3 ^ a<6); //结果 false
System.out.println(a<3 ^ a>6); //结果 true
System.out.println(a>3 ^ a<6); //结果 true
System.out.println(a>3 ^ a>6); //结果 false
6、!非
!true = false
!false = true
非真即假
非假即真
其实就是取反操作。
实例
int a = 2;
System.out.println(!(a<3)); //结果 false
System.out.println(!(a>3)); //结果 true
7、逻辑运算符总结
逻辑运算符用于连接布尔型表达式，在java中不可以写成3<a<6,应该写成a>3 & a<6。
&和&&的区别：
&： 两边都运算。
&&：当左边为false时，右边不运算。
|和||的区别：
|： 两边都运算。
||：当左边为true时，右边不运算。
^和|的不同之处：
当左右都为true时，结果为false
五、位运算符
位就是二进制的位，位运算就是直接对二进制进行运算。
计算机最快的运算是位运算，但他的局限性是以2的倍数增长。
运算符 运算 范例
<< 左移 3 << 2 = 12 --> 3*2*2=12
>> 右移 3 >> 1 = 1 --> 3/2=1
>>> 无符号右移 3 >>> 1 = 1 --> 3/2=1
& 与运算 6 & 3 = 2
| 或运算 6 | 3 = 7
^ 异或运算 6 ^ 3 = 5
~ 反码 ~ 6 = -7
1、<<向左移位：3<<2
3的二进制是11
在内存里是32位： 0000-0000 0000-0000 0000-0000 0000-0011
向左移动2位就是： 00│00-0000 0000-0000 0000-0000 0000-0011
然后在右边补2位： 00-0000 0000-0000 0000-0000 0000-0011│00
结果是： 00-0000 0000-0000 0000-0000 0000-0011 00 =12
同理得出：
3<<1=6; 3*2的1次幂
3<<2=12; 3*2的2次幂
3<<3=24; 3*2的3次幂
3<<4=48
实例：
int x = 3;
System.out.println(x << 1);//6
System.out.println(x << 2);//12
System.out.println(x << 3);//24
System.out.println(x << 4);//48
2、>>右移位
15 >> 2 = 1111
在内存里是： 0000-0000 0000-0000 0000-0000 0000-1111
向右移动2位就是： 0000-0000 0000-0000 0000-0000 0000-11│11
然后在左边补2位： 00│0000-0000 0000-0000 0000-0000 0000-11
结果15>>2是： 00 0000-0000 0000-0000 0000-0000 0000-11=3
同理得出：
15>>1=7; 15/2的1次幂=7
15>>2=3; 15/2的2次幂=3
15>>3=1; 15/2的3次幂=1
实例：
int x = 25;
System.out.println(x >> 1);//12
System.out.println(x >> 2);//6
System.out.println(x >> 3);//3
System.out.println(x >> 4);//1
结论：
<<向左移n位：乘以2的n次幂
>>向右移n位：除以2的n次幂
3、>>>无符号右移运算符
无论最高位是什么，右移后，都用0补位。右移n位就相当于除上2的n次方。
实例：
int x = 50;
System.out.println(x >>> 1);//25
System.out.println(x >>> 2);//12
System.out.println(x >>> 3);//6
System.out.println(x >>> 4);//3
>>与>>>的区别：
>>：最高位补什么由原有数据的最高位值而定。 如果最高位是0，右移后，用0补空位。 如果最高位是1，右移后，用1补空位。
>>>：无论最高位是什么，右移后，都用0补位。
4、&运算符
true是1，false是0。
两个都是1，结果是1，有一个是0，结果是0
算法：
6 & 3 = 2
系统算法：
110 => 6
& 011 => 3
-----------
010 => 2
实例：
int x = 6;
System.out.println(x & 3 );//2
5、|或运算
6 | 5 = 7
true是1，false是0,
只要有一个是1，结果是1。两个都是1，结果是1。
系统算法：
110 => 6
| 101 => 5
------------
111 => 7
实例：
System.out.println(x | 3);//7
6、^ 异或运算
6 ^ 5 = 3
有一个是1，结果是1，两个都是1，结果是0。
系统算法：
110 => 6
^ 101 => 5
------------
011 => 3
实例：
System.out.println(6 ^ 5);//3
System.out.println(6^5^5);//6
^异或结论:一个数异或一个数2此，结果还是原来的数。
由此可以发现，异或可以用于加密数据。
7、~ 反码运算
~6 = -7
其实就是取反。1=0,0=1这样取反。
系统算法：
0000...0110 => 6
------------------------
取反 1111...1001 => -7
实例：
System.out.println( ~ 6 );//-7
结论：
其实没那么复杂，其实就是这个数+1再乘以-1。
如~-5：就是-5+1=-4，然后-4*(-1)=4
如~6：就是6+1=7，然后7*(-1)=-7
如~528：528+1=529,529*(-1)=-529
验证：
System.out.println( ~-5 );//4
System.out.println( ~6 );//-7
System.out.println( ~528);//-529
六、三元运算符
格式：(条件表达式)? 表达式1 : 表达式2;
如果条件为true，运算后的结果是表达式1。
如果条件为false，运算后的结果是表达式2。
好处：可以简化if else代码。
弊端：因为是一个运算符，所以运算完必须要有一个结果。
如何获取两个数中最大值，看下面实例
实例：
int x=3,y=4,z;
z = (x>y)? x:y; //返回最大值
System.out.print(z);//4
七、练习
1、最有效率的方式算出2乘以8等于几？
答：2<<3
2、对两个整数变量的值进行互换（三种方法）。
答: //用第三方变量，这是开发中常用的。
int temp;
temp = n;
n = m;
m = temp;
//不用第三方变量，
//缺点：如果n和m的值非常大，容易超出int范围。
n = n + m;
m = n - m;
n = n - m;
//用异或的方式。不会出超出范围的情况。
//提示:一个数异或另一个数两次，结果还是原来的数。
n = n ^ m;
m = n ^ m;
n = n ^ m;
3、怎么把76转换成十六进制？
解1：
获取76的二进制，可以按4位取
76/2=38 余0
38/2=19 余0
19/2=9 余1
9/2=4 余1
4/2=2 余0
2/2=0 余0
0/2=1 余1
结果：1001100
按四位取
100 1100
--- ----
4 12
获取12的十六进制
(char)(12-10+'A') ==> C
所以76的十六进制是4C
用代码解答如下：
实例:
int num = 76; //获取60的最低4位，通过&15； int n1 = num & 15; System.out.println(n1>9?(char)(n1-10+'A'):n1);//67 //要获取下一组四位，将60右移4位。 int temp = num >>> 4;<p> //对temp的值进行最低四位的获取。 int n2 = temp & 15; System.out.println(n2>9?(char)(n2-10+'A'):n2);//4</p>
转义字符\
实例：
//输出后会显示hello world在上，hello java在下
//因为在print的后面加上ln，是在语句结束后换行。
System.out.println("hello world");
System.out.println("hello java");
//转义字符：通过\来转变后面字母或者符号的含义。
// \n：换行，可用于win和linux系统。
System.out.println("hello\nworld");
// \b：退格，相当于backspace（退格键）。
System.out.println("hello\bworld");
// \r：按下回车键，windows系统里回车符是由\r\n来表示
System.out.println("hello\r\nworld");
// \t：制表符，相当于tab键。
System.out.println("hello\tworld");
//输出带双引号的"hello world"
System.out.println("\"hello world\"");
结果
hello world
hello java
hello
world
hellworld
hello
world
hello world
"hello world"