java运算符

 

对常量和变量进行操作的过程,称为运算;

对常量和变量进行操作的符号,称为运算符.

　　算术运算符　　

　　赋值运算符　　

　　比较运算符　　

　　逻辑运算符　　

　　位运算符　　

　　三目运算符　　

 

Ø 算术运算符

 

++ 和 -- 既可以出现在操作数的左边，也可以出现在右边，但结果不同

例如：

  

 

运行结果为： 

 

 

  

运算结果为：

      

 

 

 

算术运算符++和--的用法

·a:单独使用：
　　放在操作数的前面和后面效果一样。(这种用法是我们比较常见的)
·b:参与运算使用：
　　放在操作数的前面，先自增或者自减，然后再参与运算。
　　放在操作数的后面，先参与运算，再自增或者自减。

注意:自增和自减运算符只能用于操作变量，不能直接用于操作数值或常量！

例如 5++ 、 8-- 等写法都是错误滴

 

---

 

Ø 赋值运算符

    赋值运算符是指为变量或常量指定数值,如可以使用 “=” 将右边的表达式结果赋给左边的操作数。

注：赋值运算不改变数据类型

     

 

 

 

 

 

 

 

 

 

---

 

Ø 比较运算符

    比较运算符用于判断两个数据的大小，例如：大于、等于、不等于。比较的结果是一个布尔值（ true 或 false ）。

    

    

 

 

 

 

 

 

 instanceof       检查是否是类的对象     "hello" instanceof String          true

 

注意1：

1、  > 、 < 、 >= 、 <= 只支持左右两边操作数是数值类型

2、  == 、 != 两边的操作数既可以是数值类型，也可以是引用类型

 

注意2："=="不能写成"="。

int a = 10;
int b = 20;

//boolean flag = (a == b);
//boolean flag = (a = b); 　　//这个是有问题的，不兼容的类型
//System.out.println(flag);

int c = (a = b); //把b赋值给a，然后把a留下来
System.out.println(c);　　//20

 

---

 

Ø 逻辑运算

逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。

 

· &　　逻辑与:　　有false则false。都为true则true

· &&　 短路与:　　有false则false。都为true则true

·  |  　  逻辑或:　　有true则true。都为false则false

·  || 　  短路或:　　有true则true。都为false则false

·  ^　   逻辑异或:　不同为true，相同为false

·  ! 　   逻辑非:　　非false则true，非true则false;特点:偶数个!不改变本身

 

&&和&的区别?

a:最终结果一样。

b:&&具有短路效果。左边是false，右边不执行。&是无论左边是false还是true,右边都会执行

c:“|”和“||”的区别同理，双或时，左边为真，右边不参与运算。

 

---

 

Ø 位运算符(了解)

注意：
要做位运算，首先要把数据转换为二进制。

 

 &,　　|,　　^,　　~

class OperatorDemo {
　　public static void main(String[] args) {
　　　　int a = 3;
　　　　int b = 4;

　　　　System.out.println(3 & 4);
　　　　System.out.println(3 | 4);
　　　　System.out.println(3 ^ 4);
　　　　System.out.println(~3);
　　}
}
/*
分析：因为是位运算，所以我们必须先把数据换算成二进制。

3的二进制：11
00000000 00000000 00000000 00000011
4的二进制：100
00000000 00000000 00000000 00000100

&位与运算：有0则0。
   00000000 00000000 00000000 00000011
&00000000 00000000 00000000 00000100
-----------------------------------
00000000 00000000 00000000 00000000
结果是：0

|位或运算：有1则1。
 00000000 00000000 00000000 00000011
|00000000 00000000 00000000 00000100
-----------------------------------
00000000 00000000 00000000 00000111
结果是：7

^位异或运算：相同则0，不同则1。
   00000000 00000000 00000000 00000011
&00000000 00000000 00000000 00000100
-----------------------------------
00000000 00000000 00000000 00000111
结果是：7

~按位取反运算符：0变1，1变0
   00000000 00000000 00000000 00000011
~11111111 11111111 11111111 11111100 (补码)

补码：11111111 11111111 11111111 11111100
反码：11111111 11111111 11111111 11111011
原码：10000000 00000000 00000000 00000100
结果是：-4
*/

 

^的特点：一个数据对另一个数据位异或两次，该数本身不变。
class OperatorDemo2 {
public static void main(String[] args) {
　　int a = 10;
　　int b = 20;

　　System.out.println(a ^ b ^ b); //10
　　System.out.println(a ^ b ^ a); //20
　　}
}

 

<<:左移 左边最高位丢弃，右边补齐0
>>:右移 最高位是0，左边补齐0；最高为是1，左边补齐1
>>>:无符号右移 无论最高位是0还是1，左边补齐0

class OperatorDemo3 {
　　public static void main(String[] args) {
　　//<< 　　把<<左边的数据乘以2的移动次幂
　　System.out.println(3 << 2); 　　//3*2^2 = 3*4 = 12;

　　//>> 　　把>>左边的数据除以2的移动次幂
　　System.out.println(24 >> 2);　　 //24 / 2^2 = 24 / 4 = 6
　　System.out.println(24 >>> 2);　  //6

　　System.out.println(-24 >> 2); 　　//-24 / 2^2 = -24 / 4 = -6
　　System.out.println(-24 >>> 2);　  //1073741818
　　}
}
/*

<<的移动：
计算出3的二进制：11
       00000000 00000000 00000000 00000011
(00) 000000 00000000 00000000 0000001100

>>的移动：
计算出24的二进制：11000
-24的原码：10000000 00000000 00000000 00011000
反码：11111111 11111111 11111111 11100111
补码：11111111 11111111 11111111 11101000

11111111 11111111 11111111 11101000
    1111111111 11111111 11111111 111010(00)　　 -24补码>>2

补码：1111111111 11111111 11111111 111010
反码：1111111111 11111111 11111111 111001
原码：1000000000 00000000 00000000 000110
结果：-6

>>>的移动：
计算出24的二进制：11000
-24的原码：10000000 00000000 00000000 00011000
反码：11111111 11111111 11111111 11100111
补码：11111111 11111111 11111111 11101000

11111111 11111111 11111111 11101000
0011111111 11111111 11111111 111010(00)  -24>>>2
结果：1073741818
*/

---

 

Ø 条件运算符

    条件运算符（ ? : ）也称为 “三元运算符/三目运算符”。

    语法形式：比较表达式 ？ 表达式1 ：表达式2

　　比较表达式:结果是一个boolean类型。

    运算过程：如果比较表达式的值为 true ，则返回 表达式1 的值，否则返回 表达式2 的值。

 

class OperatorDemo {
　　public static void main(String[] args) {
　　　　int x = 100;
　　　　int y = 200;

　　　　int z = ((x > y)? x: y);
　　　　//int z = ((x < y)? x: y);
　　　　//int z = ((x == y)? x: y);
　　　　//报错
　　　　//int z = ((x = y)? x : y);

　　　　System.out.println("z:"+z);
　　}
}

单目运算符：~3
双目运算符：3 + 4

 

练习：获取两个整数中的最大值
　　获取三个整数中的最大值
　　比较两个整数是否相同

class OperatorTest {
　　public static void main(String[] args) {
　　　　//获取两个整数中的最大值
　　　　int x = 100;
　　　　int y = 200;

　　　　int max = (x > y? x: y);
　　　　System.out.println("max:"+max);
　　　　System.out.println("--------");

　　　　//获取三个整数中的最大值
　　　　int a = 10;
　　　　int b = 30;
　　　　int c = 20;

　　　　//①分两步：
　　　　//A:先比较a,b的最大值
　　　　//B:拿a,b的最大值在和c进行比较
　　　　int temp = ((a > b)? a: b);
　　　　//System.out.println(temp);
　　　　int max1 = (temp > c? temp: c);
　　　　System.out.println("max1:"+max1);

　　　　//②一步搞定
　　　　//int max2 = (a > b)?((a > c)? a: c):((b > c)? b: c);
　　　　//这种做法不推荐。
　　　　//System.out.println("max2:"+max2);
　　　　System.out.println("--------");

　　　　//比较两个整数是否相同
　　　　int m = 100;
　　　　int n = 200;

　　　　//boolean flag = (m == n)? true: false;

　　　　boolean flag = (m == n);　　// m==n本身就是布尔类型
　　　　System.out.println(flag);
　　}
}

 

---

---

 

Java中运算符的优先级(从高到低)

    所谓优先级，就是在表达式中的运算顺序。Java 中常用的运算符的优先级如下表所示：

优先级 　　　　描述 　　　　　　　　运算符
1 　　　　　　 括号 　　　　 　　　　 ()、[]
2 　　　　　　 正负号 　　　　 　　　+、-
3 　　　　　　 自增自减，非 　　　　++、--、!
4 　　　　　　 乘除，取余 　　　　　 *、/、%
5 　　　　　　 加减 　　　　　　　　 +、-
6 　　　　　　 移位运算 　　　　　　 <<、>>、>>>
7 　　　　　　 大小关系 　　　　　　 >、>=、<、<=
8 　　　　　　 相等关系 　　　　　　 ==、!=
9 　　　　　　 按位与 　　　　　　　　&
10 　　　　　　 按位异或 　　　　　　 ^
11 　　　　　　 按位或 　　　　　　　  |
12 　　　　　　 逻辑与 　　　　　　 　&&
13 　　　　　　 逻辑或 　　　　　　 　||
14 　　　　　　 条件运算 　　　　　　 ?:
15 　　　　　　 赋值运算 　　　　　　 =、+=、-=、*=、/=、%=
16 　　　　　　 位赋值运算 　　　　　 &=、|=、<<=、>>=、>>>= 

级别为 1 的优先级最高，级别 16 的优先级最低。

实际开发中，一般会使用小括号辅助进行优先级管理。例如：