Java语言基础-运算符大礼包（加练习题）

最新推荐文章于 2024-05-25 22:49:47 发布

寒暄

最新推荐文章于 2024-05-25 22:49:47 发布

阅读量638

点赞数 1

分类专栏： ▶寒暄_Java 文章标签： java 补码

本文链接：https://blog.csdn.net/qq_41106844/article/details/105735702

版权

▶寒暄_Java 专栏收录该内容

46 篇文章 1 订阅

订阅专栏

算术运算符

运算符	运算	范例	结果
+	正号	+3	3
-	符号	-4	-4
+	加	3+4	7
-	减	6-4	2
*	乘	2*3	6
/	除	6/2	3
%	取模(取余)	7%5	2
++	自增，先运算后取值	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”

class AriTest{
    public static void main(String[] args) {
        int a = 2;
        int b = 4;
        int c = 7;
        String d = "He";
        String e = "llo";
        // +
        System.out.println("a+b: " + (a + b));
        // -
        System.out.println("b-a: " + (b - a));
        // *
        System.out.println("a*b: " + (a * b));
        // /
        System.out.println("b/a: " + (b / a));
        System.out.println("c/a: " + (c / a));  // 整型除于整型的结果还是整型
        double f = c / a;
        System.out.println("f: " + f);          // c / a的结果是整数3，转化为double类型就是3.0 
        double g = c / (a + 0.0);
        System.out.println("g: " + g);          // 先将其中一个数转换为小数再进行运算，结果就是3.5 
        // %
        int h = -4;
        int i = -7;
        System.out.println("c%b: " + (c % b));  // 7 / 4 = 1 ··· 3
        System.out.println("c%h: " + (c % h));  // 7 / -4 = -1 ··· 3
        System.out.println("i%b: " + (i % b));  // -7 / 4 = -1 ··· -3
        System.out.println("i%h: " + (i % h));  // -7 / -4 = 1 ··· -3   被模数为负数，结果就是负数
        // ++
        System.out.println("a++: " + (a ++));   // 这条语句执行完之后，a == 3
        System.out.println("++a: " + (++ a));   // 这条语句执行完之后，a == 4
        // byte j = 127;
        // System.out.println("j++: " + (j ++)); 这样写会报错，因为自增不会改变数据类型。
        // --
        System.out.println("a--: " + (a --));   // 这条语句执行完之后，a == 3
        System.out.println("--a: " + (-- a));   // 这条语句执行完之后，a == 2
        // +
        System.out.println("d+e: " + (d + e));


        // 练习题
        int i1 = 10;
        int i2 = 20;
        int i3 = i1++;
        System.out.print("i3= " + i3);
        System.out.println(",i1= " + i1);   // i3= 10,i1= 11
        i3 = ++ i1;
        System.out.print("i3= " + i3);
        System.out.println(",i1= " + i1);   // i3= 12,i1= 12
        i3 = i2--;
        System.out.print("i3= " + i3);
        System.out.println(",i2= " + i2);   // i3= 20,i2= 19
        i3 = --i2;
        System.out.print("i3= " + i3);
        System.out.println(",i2= " + i2);   // i3= 18,i2= 18              
    }
}

赋值运算符

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

支持连续赋值。

运算符	运算	范例	结果
=	等于	a=3	3
+=	加等于	a+=1	4
-=	减等于	a-=1	3
*=	乘等于	a*=2	6
/=	除等于	a/=2	3
%=	模除等于	a%=2	1

class SetValueTest {
    public static void main(String[] args) {
        // =
        int i1 = 10;
        byte j1 = 10;
        
        int i2,j2;
        // 连续赋值
        i2 = j2 = 10;

        int i3 = 10 , j3 = 10;


        // +=
        i1 += 1;
        System.out.println(i1);

        j1 += 1; // 不会改变数据类型
        System.out.println(j1);

        // -=
        i2 -= 1;
        System.out.println(i2);

        // *=
        j2 *= 2;
        System.out.println(j2);

        // /=
        i3 /= 2;
        System.out.println(i3);

        // %=
        j3 %= 4;
        System.out.println(j3);
        
        // 练习1
        int num1 = 1;
        num1 *= 0.1; // 1*0.1=0.1  但是num1是int类型，取整后是0
        System.out.println(num1); // 0  
        num1++;
        System.out.println(num1); // 1

        // 练习2
        int num2 = 3 , num3 = 3;
        num3 *= num2++; // num3 = num3* num2++ 因为++在后面，所以先运算再进行++操作
        System.out.println("num2= " + num2); // num2= 4
        System.out.println("num3= " + num3); // num3= 9

        // 练习3
        int num4 = 10;
        num4 += (num4++) + (++num4); // num4 = num4 + (num4++) + (++num4) = 10 + 10 + 12 
        System.out.println(num4); // 32

    }
}

比较运算符

比较运算符的结果是布尔型的，也就是要么是true，要么是false。

比较运算符 “==” 不要误写成“=”

运算符	运算	范例	结果
==	相等于	4==3	false
!=	不等于	4!=3	true
<	小于	4<3	flase
>	大于	4>3	true
<=	小于等于	4<=3	false
>=	大于等于	4>=3	true
instanceof	检查是否是类的对象	“Hello” instanceof String	true

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

        // ==
        System.out.println(a == b);

        // !=
        System.out.println(a != b);

        // <
        System.out.println(a < b);

        // >
        System.out.println(a > b);

        // <=
        System.out.println(a <= b);

        // >=
        System.out.println(a >= b);

        // instanceof
        System.out.println("Hello" instanceof String);

    }
}

逻辑运算符

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

&-逻辑与

两边都为true，则返回true；反之返回false
&& -短路与

左边为true再判断右边是否为true，左边为false则直接返回false
|-逻辑或

两边有一边为true，则返回true；反之返回false
||-短路或

左边为true则直接返回true，左边为false再判断右边是否为true
!-逻辑非

逻辑为true则返回false，逻辑为false则返回true
^-逻辑异或

两边逻辑不同则返回true，反之返回false

class LogicTest {
    public static void main(String[] args) {
        boolean b1 = true;
        boolean b2 = false;
        // &
        System.out.println("-----&-----");
        System.out.println(b1 & b1);
        System.out.println(b1 & b2);
        System.out.println(b2 & b1);
        System.out.println(b2 & b2);

        // &&
        System.out.println("-----&&-----");
        System.out.println(b1 && b1);
        System.out.println(b1 && b2);
        System.out.println(b2 && b1);
        System.out.println(b2 && b2);

        // |
        System.out.println("-----|-----");
        System.out.println(b1 | b1);
        System.out.println(b1 | b2);
        System.out.println(b2 | b1);
        System.out.println(b2 | b2);

        // ||
        System.out.println("-----||-----");
        System.out.println(b1 || b1);
        System.out.println(b1 || b2);
        System.out.println(b2 || b1);
        System.out.println(b2 || b2);

        // !
        System.out.println("-----!-----");
        System.out.println(!b1);
        System.out.println(!b2);

        // ^
        System.out.println("-----^-----");
        System.out.println(b1 ^ b1);
        System.out.println(b1 ^ b2);
        System.out.println(b2 ^ b1);
        System.out.println(b2 ^ b2);


        // &&
        int num1 = 10;
        if (b1 && (num1++ > 0)){
            System.out.println("num1: " + num1); // 11
        }else{
            System.out.println("num2: " + num1);
        }

        num1 = 10;
        if (b2 && (num1++ > 0)){
            System.out.println("num1: " + num1);
        }else{
            System.out.println("num2: " + num1); // 10
        }

        // ||
        num1 = 10;
        if (b1 || (num1++ > 0)){
            System.out.println("num1: " + num1); // 10
        }else{
            System.out.println("num2: " + num1); 
        }

        num1 = 10;
        if (b2 || (num1++ > 0)){
            System.out.println("num1: " + num1); // 11
        }else{
            System.out.println("num2: " + num1); 
        }

        // 练习1
        int x = 1 , y = 1;
        if(x++ == 2 &  ++y == 2){
            x = 7;
        }
        System.out.println("x= "+x+",y= "+y); //x= 2,y= 2


        x = 1;
        y = 1;
        if(x++ == 2 &&  ++y == 2){
            x = 7;
        }
        System.out.println("x= "+x+",y= "+y); //x= 2,y= 1


        x = 1;
        y = 1;
        if(x++ == 1 & ++y == 1){
            x = 7;
        }
        System.out.println("x= "+x+",y= "+y); //x= 2,y= 2


        x = 1;
        y = 1;
        if(x++ == 1 && ++y == 1){
            x = 7;
        }
        System.out.println("x= "+x+",y= "+y);//x= 2,y= 2 

        x = 1;
        y = 1;
        if(x++ == 1 && ++y == 2){
            x = 7;
        }
        System.out.println("x= "+x+",y= "+y);//x= 7,y= 2 


        // 练习2
        boolean bx = true;
        boolean by = false;
        short z = 42;
        if((z++ == 42) && (by = true)) z++;
        if((bx = false) || (++z == 45)) z++;
        
        System.out.println("z= " + z); //46
    }
}

位运算符

位运算符是对二进制位进行的操作。

运算符	运算	范例	结果
<<	左移	3<<2	12
>>	右移	3>>1	1
>>>	无符号右移	3>>>1	1
&	与运算	6&3	2
\|	或运算	6\|3	7
^	异或运算	6^3	5
~	取反运算	~6	-7

class BitTest {
    public static void main(String[] args) {

        /* <<  左移一位，相当于 *2
           3 ==> 0000 0011    先把十进制数转换为二进制   底层是8位一组，所以这里也用8位展示
           3<<2 ==> 0000 1100 把二进制下的有效位右移2位
           0000 1100 ==> 12   把右移后的二进制转换为十进制数      
        */
        System.out.println("3<<2: " + (3<<2));

        //  负数左移也相当于 左移一位 *2
        System.out.println("-3<<2: " + (-3<<2));

        /* >>  右移一位，相当于 /2
           3 ==> 0000 0011   
           3>>1 ==> 0000 0001          （右移时，因为是正数，所以最高位补0）
           0001 ==> 1 
        */ 
        System.out.println("3>>1: " + (3>>1));

        /*但是负数右移就要注意了
          首先怎么用二进制表示-3呢
          -3的二进制原码    1000 0011 （最高位的1，表示是-号）
          -3的二进制反码    1111 1100
          -3的二进制补码    1111 1101  （负数的补码为其数值位部分取反加一）
          右移一位后的补码  1111 1110  （右移后，因为是负数，所以最高位补1）
          右移一位后的反码  1111 1101
          右移一位后的原码  1000 0010
          1000 0010 ==> -2
        */
        System.out.println("-3>>1: " + (-3>>1));
    
        // >>>  正数的情况下和 >> 结果一致 
        System.out.println("3>>>1: " + (3>>>1));

        /* 
          负数的情况下是
          原码：1111 1111 1111 1111 1111 1111 1111 0011
          反码：1111 1111 1111 1111 1111 1111 1111 1100
          补码：1111 1111 1111 1111 1111 1111 1111 1101
          右移：1111 1111 1111 1111 1111 1111 1111 1110 ==> 2147483646
        */
        System.out.println("-3>>>1: " + (-3>>>1));

        /*& 按位与   同一位上，都是1，才是1
            6 ==> 0000 0110
            3 ==> 0000 0011
            & ==> 0000 0010 ==> 2
        */
        System.out.println("6&3: " + (6&3));

        /*| 按位或   同一位上，有一个是1，就是1
            6 ==> 0000 0110
            3 ==> 0000 0011
            | ==> 0000 0111 ==> 7
        */
        System.out.println("6|3: " + (6|3));

        /*^ 按位异或  同一位上，不同则为1
            6 ==> 0000 0110
            3 ==> 0000 0011
            ^ ==> 0000 0101 ==> 5
        */
        System.out.println("6^3: " + (6^3));

        /*~ 取反 1为0,0为1
            6 ==> 0000 0110
            ~ ==> 0000 1001 ==> 7
        */
        System.out.println("~6: " + (~6));
    }
}

三元运算符

(条件表达式)? 表达式1 : 表达式2
说明：
当条件表达式为true时，执行表达式1；
当条件表达式为false时，执行表达式2.

class SanYuanTest {
    public static void main(String[] args) {
        int a = 10;
        int b = 12;
        int max = (a>b) ? a : b;
        System.out.println(max);
    }
}

注意点：表达式1和表达式2的返回值应当可以被隐式转换为接收结果的变量的类型。

而且三元运算符可以无限嵌套。

class SanYuanTest {
    public static void main(String[] args) {
        int a = 10;
        int b = 12;

        String maxStr = (a > b) ? "a大" : ((a == b) ? "a和b相等" : "b大");
        System.out.println(maxStr);
    }
}

运算符优先级

寒暄

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java语言基础-运算符大礼包（加练习题）

算术运算符运算符运算范例结果+正号+33-符号-4-4+加3+47-减6-42*乘2*36/除6/23%取模(取余)7%52++自增，先运算后取值a=2；b=++aa=3;b=3++自增，先取值后运算a=2；b=a++a=3;b=2–自减，先运算后取值a=2；b...
复制链接

扫一扫