Java运算符

Posted on Edited on

Java中的运算符分为以下几类：

  1. 算数运算符

  2. 赋值运算符

  3. 比较运算符（关系运算符）

  4. 逻辑运算符

  5. 位运算符

  6. 三元运算符

  • 算数运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
class AriTest{

	public static void main(String[] args){

		//除号
		int num1 = 12;
		int num2 = 5;
		int result1 = num1 / num2;
		System.out.println(result1); // 2 
	
        int result2 = num1 / num2 * num2;
		System.out.println(result2); // 10
	
        double result3 = num1 / num2;
		System.out.println(result3); // 2.0
	
        double result4 = num1 / num2 + 0.0; // 2.0
		double result5 = num1 / (num2 + 0.0); //2.4
		System.out.println(result5);
	
        double result6 = (double)num1 / num2; // 2.4
		System.out.println(result6);

	
        // % 取摸运算
        //结果的符号和被模数的符号相同

		int m1 = 12;
		int n1 = 5;
		System.out.println(m1 % n1); //2

		int m2 = -12;
		int n2 = 5；
        System.out.println(m2 % n2); // -2
        
        
        
        int m3 = 12;
        int n3 = -5;
        System.out.println(m3 % n3); // 2
        
        int m4 = -12;
        int n4 = -5;
        System.out.println(m4 % n4); // -2
        
        
        //自加运算
        
        //（前）++ 先自增1，再运算 
        //(后) ++ 先运算，在自增1 
        int a1 = 10;
        int b1 = ++a1;
        System.out.println("a1 = " + a1 + ",b1 = " + b1); // b1 = 11
        
        int a2 = 10;
        int b2 = a2++;
        System.out.println("a2 = " + a2 + ",b2 = " + b1);  //b2 = 10
        
        int a3 = 10;
        a3++;
        //++a3;
        int b3 = a3;   //b3 = 11
        
        
        //(前) -- 先自减1，再运算
        //(后) -- 先运算，再自减1
    }

}

​ 经常使用取模运算来判断是否能被除尽的情况；

注意点：

==自增自减运算不会改变数据自身的数据类型==

1
2
3
4
short a1 = 10;
a1 = a1 + 1;  //数据类型自动提升为int型，编译失败
a1 = (short)(a1 + 1);   //强制类型转换，正确的
a1++;   //自增自减不会改变数据自身的数据类型

练习：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
/*
随意给出一个整数，打印显示他的个位数，十位数，百位数的值
格式如下：
数字xxx的情况如下：
个位数：
十位数：
百位数：

例如：数字153的情况如下：
个位数：3
十位数：5
百位数：1
*/
public class AriExer {
    public static void main(String[] args){
        //实例化一个从键盘输入的对象
        Scanner re = new Scanner(System.in);
        //从键盘输入一个整数
        int num = re.nextInt();

        //计算百位数
        int hundredDigits = num / 100;
        //计算十位数
        int tenDigits = num / 10 - hundredDigits * 10; //int tenDigits = num % 100 / 10; //int tenDigits = num / 10 % 10;
        //计算个位数
        int single = num % 10;

        System.out.println("数字" + num + "的情况如下：");

        System.out.println("个位数：" + single);

        System.out.println("十位数：" + tenDigits);

        System.out.println("百位数：" + hundredDigits);
    }
}

  • 赋值运算符

    • 符号 ”=“

      当”=“两侧数据类型不一致时，可以使用自动类型转换或者强制类型转换原则进行处理。

      ==支持连续赋值==

      1
      2
      3
      4
      5
      int i1 = 10;
      int j1 = 10;

      int i2,j2;
      i2 = j2 = 10;

    • *扩展赋值运算符：+=, -= , =, /=, %=

​ 注意点：

​ ==赋值运算符的拓展运算符也不会改变数据自身的数据类型。==

1
2
3
short a = 10;
a = a + 2;  //编译错误，a + 2 的结果为int型
a += 2;  //值为12，编译成功

练习1：

1
2
3
4
5
int i = 1;
i *= 0.1;    //*=不会改变数据自身的数据类型，所以编译成功
System.out.println(i);  //0
i++;
System.out.println(i);  //1

练习2：

1
2
3
4
5
int m = 2;
int n = 3;
n *= m++;
System.out.println("m = " + m); //3
System.out.println("n = " + n); //6

练习3：

1
2
3
int n = 10;
n += (n++) + (++n);   //实际开发中不建议这种写法
System.out.println(n);  //32

开发中，希望变量实现 +2 的操作，实现方式

1
int num = 10;

方式一：

1
num += 2;

方式二：

1
num = num + 2;

  • 比较运算符

    • 比较运算符的结果都是boolean类型，要么是true，要么就是false。

    • 比较运算符”==”不能写成”=”

      1
      2
      3
      4
      5
      int i = 20;
      int j = 10;

      System.out.println(i == j); //false
      System.out.println(i = j); //10

    运算符：==, !=, <, >, <=, >=, instanceof(检查是否是类的对象)

    1
    "Hello" instanceof String  //true

思考：

1
2
3
4
boolean b1 = true;
boolean b2 = false;
System.out.println(b1 == b2); //false
System.out.println(b2 = b1); //true

  • 逻辑运算符

    & ——逻辑与； | ——逻辑或； ! ——逻辑非； && ——短路与； || ——短路或； ^ ——逻辑异或

a b a&b a|b !a a||b a&&b a^b
true true true true false true true false
true false false true false true false true
false false false false true false false false
false true false true true true false true

说明：逻辑运算符操作的都是boolean类型的变量（位运算中也有&、|、^，区别在于逻辑运算符操作的是boolean类型的变量，位运算符操作的是数值类型）。

区分 & 与 &&

相同点：

  1. 运算结果相同
  2. 当符号左边是true时，都会执行符号右边的内容

不同点：

  1. 当符号左边是false时，&&不会执行符号右边的内容
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
boolean b1 = false;
int num1 = 10;
if(b1 & (num1++ > 0)){     //逻辑与会判断
    System.out.println("我在北京");
}else{
    System.out.println("我在南京");
}

System.out.println(num1);    //11

boolean b2 = false;
int num2 = 10;
if(b2 && (num2++ > 0)){
    System.out.println("我在北京");
}else{
    System.out.println("我在南京");
}

System.out.println(num2);    //10

区分 | 与 ||

相同点：

  1. 运算结果相同
  2. 当符号左边是false时，都会执行符号右边的内容

不同点：

  1. 当符号左边是true时，||不会执行符号右边的内容
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
boolean b1 = true;
int num1 = 10;
if(b1 | (num1++ > 0)){     //逻辑与会判断
    System.out.println("我在北京");
}else{
    System.out.println("我在南京");
}

System.out.println(num1);    //11

boolean b2 = true;
int num2 = 10;
if(b2 || (num2++ > 0)){
    System.out.println("我在北京");
}else{
    System.out.println("我在南京");
}

System.out.println(num2);    //10

练习：

1
2
3
4
5
6
int x = 1;
int y = 1;
if(x++ == 2 & ++y == 2){
    x = 7;
}
System.out.println("x = " + x + "y = " + y);  //x = 2 ,y = 2
1
2
3
4
5
6
int x = 1;
int y = 1;
if(x++ == 2 && ++y == 2){
    x = 7;
}
System.out.println("x = " + x + "y = " + y);  //x = 2 ,y = 1
1
2
3
4
5
6
int x = 1;
int y = 1;
if(x++ == 1 | ++y == 1){
    x = 7;
}
System.out.println("x = " + x + "y = " + y);  //x = 7 ,y = 2
1
2
3
4
5
6
int x = 1;
int y = 1;
if(x++ == 1 || ++y == 1){
    x = 7;
}
System.out.println("x = " + x + "y = " + y);  //x = 7 ,y = 1

z 的结果为：46

1
2
3
4
5
6
7
8
boolean x = true;
boolean y = false;
short z = 42;
if((z++ == 42) && (y == true))
    z++;
if((x == false) || (++z == 45))
    z++;
System.out.println("z = " + z);

  • 位运算符

    • 位运算符是直接对整数的二进制进行的运算
    • 左移 ： 在一定范围内，每向左移一位，相当于 * 2
    • 右移 ： 在一定范围内，每向右移一位，相当于 / 2
运算符 运算 范例
<< 左移(==高位丢弃，空位补0==) 3 << 2 = 12 —> 3 * 2 * 2 = 12
>> 右移(==若高位是0，右移后，空位补0；若高位是1，右移后，空位补1==) 3 >> 1 = 1 —> 3 / 2 = 1
>>> 无符号右移(==无论高位是0或1，空位都补0==) 3 >>> 1 = 1 —> 3 / 2 = 1
& 与运算 6 & 3 = 2
| 或运算 6 | 3 = 7
^ 异或运算 6 ^ 3 = 5
~ 取反运算 ~6 = -7

思考：最高效的方式计算 8 * 2 

1
2
3
4
5
6
int num = 2;
num << 3;
/*
int num = 8;
num << 1;
*/

练习：交换两个变量的值

1
2
int num1 = 10;
int num2 = 20;

方式一：

1
2
3
4
int temp = 0;
temp = num1;
num1 = num2;
num2 = temp;

方式二：

好处：不用定义变量

弊端：

  1. 可能超出存储范围
  2. 有局限性（不同数据类型）
1
2
3
num1 = num1 + num2;
num2 = num1 - num2;
num1 = num1 - num2

方式三：

1
2
3
num1 = num1 ^ num2;
num2 = num1 ^ num2;
num1 = num1 ^ num2;

  • 三元运算符

    1. **格式： ==(条件表达式) ? 表达式1 : 表达式2== **
    2. 表达式1与表达式2是同种类型
    3. 三元运算符与 if-else 的联系与区别
      • 三元运算符可简化 if - else 语句
      • 三元运算符要求必须返回一个值
      • if-else 代码块可以有多个语句
    4. 三元运算符可以嵌套使用
    5. 凡是使用三元运算符的地方都可以改写成if-else语句，反之，不成立。

  • 运算符的优先级

优先级 运算符 结合性
1 ()、[]、{} 从左向右
2 !、+、-、~、++、– 从右向左
3 *、/、% 从左向右
4 +、- 从左向右
5 «、»、>>> 从左向右
6 <、<=、>、>=、instanceof 从左向右
7 ==、!= 从左向右
8 & 从左向右
9 ^ 从左向右
10 | 从左向右
11 && 从左向右
12 || 从左向右
13 ?: 从右向左
14 =、+=、-=、*=、/=、&=、|=、^=、~=、«=、»=、>>>= 从右向左

==注意：只有单目运算、赋值运算、三元运算符是从右向左运算的==