流水不争先，争的是滔滔不绝

算术运算符

操作符描述例子
+加法A + B
-减法A – B
*乘法A * B
/除法B / A
％取余B % A
++自增（前）: 先运算后取值
自增（后）: 先取值后运算		++B
B++
–自减（前）: 先运算后取值
自减（后）: 先取值后运算		–B
B–
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
class Day03Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 3;
        System.out.println("a + b = " + (a + b));    // a + b = 13
        System.out.println("a - b = " + (a - b));    // a - b = 7
        System.out.println("a * b = " + (a * b));    // a * b = 30
        System.out.println("a / b = " + (a / b));    // a / b = 3
        System.out.println("a % b = " + (a % b));    // a % b = 1
        
        int c = 3;
        System.out.println(c++);    // 3
        System.out.println(c);    // 4
        
        int d = 4;
        System.out.println(++d);    // 5
        
        int e = 5;
        System.out.println(e--);    // 5
        System.out.println(e);    // 4
        
        int f = 6;
        System.out.println(--f);    // 5
    }
}

案例1

随意给出一个整数，打印显示它的个位数，十位数，百位数的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
 * 打印个位十位百位
 */
public class ArithmeticExer1 {
    public static void main(String[] args) {
        int num = 187;
        int bai = num / 100;
        int shi = num % 100 / 10; // int shi = num / 10 % 10;
        int ge = num % 10;

        System.out.println("百位为：" + bai);
        System.out.println("十位为：" + shi);
        System.out.println("个位为：" + ge);
    }
}

拓展：获取一个四位数的个位，十位，百位，千位

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class ArithmeticExer2 {
    public static void main(String[] args) {
        int num = 1234;

        int qian = num / 1000 % 10;
        int bai = num / 100 % 10;
        int shi = num / 10 % 10;
        int ge = num % 10;

        System.out.println("千位为：" + qian);
        System.out.println("百位为：" + bai);
        System.out.println("十位为：" + shi);
        System.out.println("个位为：" + ge);
    }
}

案例2

为抵抗洪水，战士连续作战89小时，编程计算共多少天零多少小时

1
2
3
4
5
6
7
8
9
public class ArithmeticExer4 {
    public static void main(String[] args) {
        int hours = 89;
        int day = hours / 24;
        int hour = hours % 24;
        System.out.println("为抵抗洪水，战士连续作战 89 小时：");
        System.out.println("为抵抗洪水，战士连续作战 " + day + " 天 " + hour + " 小时");
    }
}

赋值运算符

操作符描述例子
=简单的赋值运算符，将右操作数的值赋给左侧操作数C = A + B将把A + B得到的值赋给C
+=加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数C += A等价于C = C + A
-=减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数C -= A等价于C = C - A
*=乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数C *= A等价于C = C * A
/=除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数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

关系运算符

运算符描述例子结果
==检查如果两个操作数的值是否相等，如果相等则条件为真。(A == B)为假。false
!=检查如果两个操作数的值是否相等，如果值不相等则条件为真。(A != B) 为真。true
>检查左操作数的值是否大于右操作数的值，如果是那么条件为真。(A> B)为假。flase
<检查左操作数的值是否小于右操作数的值，如果是那么条件为真。(A <B)为真。true
>=检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。(A> = B)为假。flase
<=检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。(A <= B)为真。true
1
2
3
4
5
6
7
8
9
10
11
12
class Day03Test1 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("a == b → " + (a == b));    // false
        System.out.println("a != b → " + (a != b));    // true
        System.out.println("a > b → " + (a > b));    // false
        System.out.println("a < b → " + (a < b));    // true
        System.out.println("a >= b → " + (a >= b));    // false
        System.out.println("a <= b → " + (a <= b));    // true
    }
}

逻辑运算符

操作符描述例子
&&称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。(A && B)为假。
| |称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。(A | | B)为真。
！称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。!(A && B)为真。

当用于逻辑运算时的区别

  • “&” 和 “&&” 的区别：

    • 单 & 时，左边无论真假，右边都进行运算；
    • 双 & 时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。

  • “|” 和 “||”的区别同理，|| 表示：当左边为真，右边不参与运算。

  • 异或(^)与或( | )的不同之处是：当左右都为true时，结果为false。理解：异或，追求的是“异”!

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
class LogicTest {
    public static void main(String[] args) {
        //区分& 与 &&
        //相同点1：& 与  && 的运算结果相同
        //相同点2：当符号左边是true时，二者都会执行符号右边的运算
        //不同点：当符号左边是 false 时，& 继续执行符号右边的运算。&&不再执行符号右边的运算。
        //开发中，推荐使用 &&
        
        boolean b1 = false;
        int num1 = 10;
        if(b1 & (num1++ > 0)){
            System.out.println("北京");
        }else{
            System.out.println("南京");
        }
        System.out.println("num1 = " + num1); //11
        
        boolean b2 = false;
        int num2 = 10;
        if(b2 && (num2++ > 0)){
            System.out.println("北京");
        }else{
            System.out.println("南京");
        }
        System.out.println("num2 = " + num2); //10
        
        // 区分：| 与 || 
        //相同点1：| 与  || 的运算结果相同
        //相同点2：当符号左边是 false 时，二者都会执行符号右边的运算
        //不同点3：当符号左边是 true 时，| 继续执行符号右边的运算，而 || 不再执行符号右边的运算
        //开发中，推荐使用||
        boolean b3 = false;
        b3 = true;
        int num3 = 10;
        if(b3 | (num3++ > 0)){
            System.out.println("北京");
        }else{
            System.out.println("南京");
        }
        System.out.println("num3 = " + num3); //11


        boolean b4 = false;
        b4 = true;
        int num4 = 10;
        if(b4 || (num4++ > 0)){
            System.out.println("北京");
        }else{
            System.out.println("南京");
        }
        System.out.println("num4 = " + num4); //10
    }
}
1
2
3
4
5
6
7
8
9
10
class LogoinTest {
    public static void main(String[] args) {
        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); //46
    }
}

案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/**
 * 1. 定义类 CompareLogicExer
 * 2. 定义 main方法
 * 3. 定义一个int类型变量a,变量b,都赋值为20
 * 4. 定义boolean类型变量bo1 , 判断++a 是否被3整除,并且a++ 是否被7整除,将结果赋值给bo1
 * 5. 输出a的值,bo1的值
 * 6. 定义boolean类型变量bo2 , 判断b++ 是否被3整除,并且++b 是否被7整除,将结果赋值给bo2
 * 7. 输出b的值,bo2的值
 */
public class CompareLogicExer1 {
    public static void main(String[] args) {
        int a = 20;
        int b = 20;
        boolean bo1 = (++a % 3 == 0) && (a++ % 7 == 0);
        System.out.println("a = " + a); // 22
        System.out.println("bo1 = " + bo1); // true
        boolean bo2 = (b++ % 3 == 0) && (++b % 7 == 0);
        System.out.println("b = " + b); // 21
        System.out.println("bo2 = " + bo2); // false
    }
}

位运算符

Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。

位运算符作用在所有的位上，并且按位运算。假设a = 60，b = 13;它们的二进制格式表示将如下

A = 0011 1100 B = 0000 1101

A & B = 0000 1100

A | B = 0011 1101

A ^ B = 0011 0001

~A = 1100 0011

下表列出了位运算符的基本运算，假设整数变量 A 的值为 60 和变量 B 的值为 13：

操作符描述例子
＆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
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
public class Test3 {
    public static void main(String[] args) {
        int a = 60; /* 60: 0011 1100 */
        int b = 13; /* 13: 0000 1101 */
        int c = a & b; /* 12: 0000 1100 */
        System.out.println(c); // 12

        int d = a | b; /* 61: 0011 1101 */
        System.out.println(d); // 61

        int e = a ^ b; /* 49: 0011 0001 */
        System.out.println(e); // 49

        int f = ~a; /* -61: 1100 0011 */
        System.out.println(f); // -61

        int g = a << 2; /* 240: 1111 0000 */
        System.out.println(g); // 240

        int h = a >> 2; /* 15: 1111 */
        System.out.println(h); // 15

        int i = a >>> 2; /* 15: 0000 1111 */
        System.out.println(i); // 15
    }
}

计算过程

案例

如何交换两个 int 型变量的值？String 呢？

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
public class BitExer {
    public static void main(String[] args) {
        int m = 10;
		int n = 5;

		System.out.println("m = " + m + ", n = " + n);

		//（推荐）实现方式1：优点：容易理解，适用于不同数据类型    缺点：需要额外定义变量
		//int temp = m;
		//m = n;
		//n = temp;

		//实现方式2：优点：没有额外定义变量    缺点：可能超出int的范围；只能适用于数值类型
		//m = m + n; //15 = 10 + 5
		//n = m - n;//10 = 15 - 5
		//m = m - n;//5 = 15 - 10
	
		//实现方式3：优点：没有额外定义变量    缺点：不易理解；只能适用于数值类型
		m = m ^ n; 
		n = m ^ n; //(m ^ n) ^ n
		m = m ^ n;

		System.out.println("m = " + m + ", n = " + n);
    }
}

条件运算符

条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

三元运算符后面的表达式1和表达式2必须为同种类型，编译时可能会自动类型提升

variable x = (expression) ? value if true : value if false

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
public class Test4 {
    public static void main(String[] args) {
        int m = 12;
        int n = 5;
        int max = (m > n) ? m : n;
        System.out.println(max); // 12

        n = 15;
        // 三元运算符可以嵌套
        String str = (m > n) ? "m大" : ((m == n) ? "m和n相等" : "n大");
        System.out.println(str); // n大

        //*****************
        // 获取三个数值的最大值
        int n1 = 12;
        int n2 = 30;
        int n3 = -43;
        int max1 = (n1 > n2) ? n1 : n2;
        int max2 = (max1 > n3) ? max1 : n3;
        System.out.println(max2); // 30

        // 不建议这样写，可读性太差
        int max3 = (((n1 > n2) ? n1 : n2) > n3) ? ((n1 > n2) ? n1 : n2) : n3;
        System.out.println(max3);
    }
}

案例

要求：控制台输出”今天是周2，10天以后是周x”

1
2
3
4
5
6
7
8
public class ConditionExer3 {
    public static void main(String[] args) {
        int week = 2;
        week += 10;
        week %= 7;
        System.out.println("今天是周2, 10天以后是周" + (week == 0 ? "日" : week));
    }
}

运算符的优先级

  • 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如下表，上一行运算符总优先于下一行。
  • 只有单目运算符、三元运算符、赋值运算符是从右向左运算的

优先级