Java-运算符

爱是小小的癌

于 2024-10-04 23:45:41 发布

阅读量1.1k

点赞数 38

分类专栏： JavaSE 文章标签： java 开发语言算法

本文链接：https://blog.csdn.net/ixiaotang_/article/details/142707215

版权

JavaSE 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一、运算符是什么？

其实就如字面意思一样啦~就像数学中的运算符一样:(" + "，" - "，" * "，" / "，" % "...)。

计算机的用途就如其名：运算。而既然要运算，肯定就需要运算符。

而在Java中也提供了非常多的运算符来操控变量，而其中的运算符基本可以分为以下六种：

1. 算术运算符

2. 比较运算符

3. 逻辑运算符

4. 位运算符

5. 位移运算符

6. 条件运算符（三元运算符）

二、算数运算符

① 四则运算符

算术运算符：包括加法运算符（+）、减法运算符（-）、乘法运算符（*）、除法运算符（/）、取余运算符（%）等，用于进行基本的数学运算。

加法运算符（+）：用于将两个数相加。例如：int a = 5 + 3; // a的值为8

减法运算符（-）：用于将一个数减去另一个数。例如：int b = 7 - 2; // b的值为5

乘法运算符（*）：用于将两个数相乘。例如：int c = 4 * 6; // c的值为24

除法运算符（/）：用于将一个数除以另一个数。注意，如果除法操作涉及整数，结果将被截断为整数。例如：int d = 10 / 3; // d的值为3

取模运算符（%）：用于计算两个数的除法余数。例如：int e = 10 % 3; // e的值为1

📚 代码演示：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner num = new Scanner(System.in);
        int n = num.nextInt();
        System.out.println(n+5);
        System.out.println(n-5);
        System.out.println(n*5);
        System.out.println(n/5);
        System.out.println(n%5);
    }
}

由此我们便能看出(" + "，" - "，" * "，" / "，" % ")的作用就是"相加"，"相减"，"相乘"，"相除"，"取余"，是与数学中的用法一致的。

📌 而对于这些算数操作符，有以下注意事项：

📕 以上运算符都是二元运算符，使用时必须有左右两个操作数。

📕 int / int 结果还是 int 类型，而且会向下取整。

📕 int 型 2 / 3 得到的是 1 而非 1.5。(小数点后舍弃)

📕 做除法和取模时，右操作数不能为0。

📕 % 不仅可以对整型取模，也可以对double类型取模，但是没有意义，一般都是对整型取模的。

📕 两侧操作数类型不一致时，向类型大的提升。

② 增量运算符

而除了此类比较简单的算术操作符以外，还有一些编译器中的语言，如增量运算符。

📚 其实很简单，只是上述四则运算中的简化版本：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner num = new Scanner(System.in);
        int n = num.nextInt();
        n += 5;
        //n = n + 5
        System.out.println(n);
        n -= 2;
        //n = n - 2
        System.out.println(n);
        n *= 3;
        //n = n * 3
        System.out.println(n);
        n /= 3;
        //n = n / 3
        System.out.println(n);
        n %= 2;
        //n = n % 2
        System.out.println(n);
    }
}

" += "，" -= "，" *= "，" /= "，" %= "都是直接改变操作变量，运算结束后将结果赋值给左操作数。

📌 注意事项：

📕 只有变量才能使用该运算符，常量不能使用。

③ 自增/自减操作符

自增，自减操作符分别是" ++ "，" -- "，作用分别是使变量+1和变量-1。

Java中的增量运算符有两种形式：前缀形式和后缀形式。

📌 前缀形式：

📕 ++ ：递增操作符，将操作数的值加1，并返回加1后的值。

📕 -- ：递减操作符，将操作数的值减1，并返回减1后的值。

📚 代码演示：

public class Main {
    public static void main(String[] args) {
        int i = 0;
        if(++i == 0)
            System.out.println("Yes");
        else
            System.out.println("No");
    }
}

注意，前置" ++ "代表将此变量 +1 后直接使用该变量(否则则会打印"Yes")。

public class Main {
    public static void main(String[] args) {
        int i = 1;
        if(--i == 0)
            System.out.println("Yes");
        else
            System.out.println("No");
    }
}

注意，前置" -- "代表将此变量 -1 后直接使用该变量(否则则会打印"No")。

📌 后缀形式：

📕 ++ ：递增操作符，将操作数的值加1，并返回加1之前的值。

📕 -- ：递减操作符，将操作数的值减1，并返回减1之前的值。

📚 代码演示：

public class Main {
    public static void main(String[] args) {
        int i = 0;
        if(i++ == 0)
            System.out.println("Yes");
        else
            System.out.println("No");
    }
}

注意，后置" ++ "先使用未自增的变量，而后再将变量 +1(否则则会打印"No")。

public class Main {
    public static void main(String[] args) {
        int i = 1;
        if(i-- == 0)
            System.out.println("Yes");
        else
            System.out.println("No");
    }
}

注意，后置" -- "先使用未自增的变量，而后再将变量 -1(否则则会打印"Yes")。

三、关系运算符

Java中的关系运算符包括以下几种：

等于：==

不等于：!=

大于：>

小于：<

大于等于：>=

小于等于：<=

这些运算符用于比较两个操作数的关系，并返回一个布尔值，表示比较结果的真或假。比较操作符通常用于条件语句、循环语句等控制结构中，用于确定程序的执行流程。

📚 代码演示：

public class Main {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        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);
    }
}

📌注意：当需要多次判断时不能连着写，比如：7 < a < 19 是不行的。

四、逻辑运算符

Java中的逻辑运算符有以下几种：

📕 与运算符（&&）：当且仅当两个操作数都为true时，结果为true；否则结果为false。

📕 或运算符（||）：当且仅当两个操作数都为false时，结果为false；否则结果为true。

📕 非运算符（！）：用于取反，当操作shu数为true时，结果为false；当操作数为false时，结果为true。

逻辑运算符通常用于条件判断或控制流程中，可以用来组合多个条件或将条件取反。

📚 代码演示：

public class Main {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        if(a == 1 || b == 3)
            System.out.println("Yes");
    }
}

(这是因为两种条件中有一方为真，所以就运行if语句，并且打印"Yes")

但如果将" || "改成" && "，就能够发现：什么都不会打印出来了，因为" && "必须两个条件都符合。

📌 需要注意的是，逻辑运算符有" 短路规则 "：

📕 短路原则：在逻辑运算符( && 和 || )中，如果根据左侧操作数的值可以确定整个表达式的结果时，右侧操作数将不会被执行。

📚 代码演示：

public class Main {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        if(a == 10 || false)
            System.out.println("Yes");
    }
}

我们知道，false代表假，如果操作到了false，便不会输出，而最后还是输出了"Yes"。

(如果是C/C++语言环境下，可以通过" ++ "，" -- "来进行演示，但Java不可以，因为Java语言拥有较强的严谨性，而且 boolean 只有 " true "与" false "，并不是" 0 "与" 非0 ")

📌 而"！"的作用是：使" 真变假 "，" 假变真 "。

📚 代码演示：

public class Main {
    public static void main(String[] args) {
        int a = 10;
        System.out.println("使用!前:");
        System.out.println(!(a == 10));
        System.out.println(!(a != 10));
        System.out.println("使用!后:");
        System.out.println((a == 10));
        System.out.println((a != 10));
    }
}

五、位运算符

📌 Java中的位运算符包括以下几种：

📕 位与运算符（&）：对两个操作数的每个位执行逻辑与操作，只有当两个位都为1时，结果才为1，否则为0。

📕 位或运算符（|）：对两个操作数的每个位执行逻辑或操作，只要两个位中有一个为1时，结果就为1，否则为0。

📕 位异或运算符（^）：对两个操作数的每个位执行逻辑异或操作，只有当两个位不相同时，结果才为1，否则为0。

📕 位非运算符（~）：对操作数的每个位执行逻辑非操作，将1变为0，将0变为1。

① 位与运算符（&）

📌 同为1才为1，否则为0；

public class Main {
    public static void main(String[] args) {
        int a = -5;
        int b = 7;
        System.out.println(a&b);
    }
}

int型在32位机器上占四个字节，那么高位补零，让我们看一下-5和7的原码：

a->10000000000000000000000000000101
 
b->00000000000000000000000000000111

分别求出a和b的补码，先对原码取反，然后再对反码+1。

a->10000000000000000000000000000101
   11111111111111111111111111111010//求反
   11111111111111111111111111111011//+1，补码
b->00000000000000000000000000000111//正数的补码与反码相同
//&：同为1才为1，否则为0；
得 a&b为00000000000000000000000000000011//输出结果为3

② 位或运算符（|）

📌 有1就为1；

接下来我们看|(或)操作符，同样是a与b的补码来进行计算

11111111111111111111111111111011//a补码
00000000000000000000000000000111//b反码
//|(或)操作符：有1就为1；
a|b->11111111111111111111111111111111//(还得取反+1变成原码才行)
   ->10000000000000000000000000000000
   ->10000000000000000000000000000001//输出-1

③ 位异或运算符（^）

📌 不同为1，否则为0；

接下来我们看^（异或）操作符，同样是用a与b的补码来进行计算

11111111111111111111111111111011//a补码
00000000000000000000000000000111//b反码
//^（异或）：不同为1，否则为0；
a^b->11111111111111111111111111111100//(还得取反+1变成原码才行)
   ->10000000000000000000000000000011
   ->10000000000000000000000000000100//输出-4

④ 位非运算符（~）

📌 按位取反，0变1，1变0；

这个与前三种不太一样，就是字面意思的取反效果，我们换一个表达式来体现它的效果和作用。

public class Main {
    public static void main(String[] args) {
        System.out.println(~0);
        //00000000000000000000000000000000
        //取反
        //11111111111111111111111111111111(再取反+1)
        //10000000000000000000000000000001(-1)
    }
}

注意：如果两个数相同，则异或的结果为0

六、移位运算

📌 移位运算符有以下几种：

📕 左移运算符（<<）：将操作数的所有位向左移动指定的位数，左移n位相当于乘以2的n次方。

📕 右移运算符（>>）：将操作数的所有位向右移动指定的位数，右移n位相当于除以2的n次方。

📕 无符号右移运算符（>>>）：将操作数的所有位向右移动指定的位数，并在左侧插入0，无符号右移不考虑符号位，即使是负数也将其当作正数处理。

① 左移操作符（<<）

左移操作符使二进制数向左移动1位，那么最左边的数就被挤出去了，而右边也是同理，光说可能不太明白，没关系，我们看个图。

像这样就是一个为10的数字向左位移1位的样子了。

📚 代码演示：

public class Main {
    public static void main(String[] args) {
        int num = 10;
        num = num << 1;
        System.out.println(num);
    }
}

有没有发现什么？向左位移一次就让结果变成了2倍，这是巧合吗？让我们再试一次：

public class Main {
    public static void main(String[] args) {
        int num = 10;
        int i = 0;
        for(i = 0;i < 10;i++) {
            num = num << 1;
            System.out.println(num);
        }
    }
}

看来往左移动多少位，数字就会乘以相应次数的2~

② 右移操作符（>>）

📌 和左移操作符基本一样，有一点不同的是：左移操作符是向右补位，没有正负之分，而右移操作符是向左补位，有正负之分，于是右移操作符有两种形式。

逻辑右移：左边用0补充，右边丢弃。

算术右移：左边用原来的符号位补充，右边丢弃。

（还需要注意的是位移操作符不能移动负数位）

📚 代码演示：

public class Main {
    public static void main(String[] args) {
        int num = 5120;
        int i = 0;
        for(i = 0;i < 10;i++) {
            num = num >> 1;
            System.out.println(num);
        }
    }
}

③ 无符号右移运算符（>>>）

📌 最右侧不要了，最左侧补0；

public class Main {
    public static void main(String[] args) {
        int a = 0xffffffff;
        System.out.printf("%x\n", a >>> 1);
        // 运行结果(注意, 是按十六进制打印的)
    }
}

七、条件运算符

Java条件运算符是用于在条件表达式中进行判断和选择的特殊运算符，只有一个：

三目运算符：三目运算符用于根据条件的真假来选择两个不同的值。

语法：条件表达式 ? 表达式1 : 表达式2

如果条件表达式为真，则返回表达式1的值；如果条件表达式为假，则返回表达式2的值。

📚 代码演示：

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