JAVA(七)运算符

薛定谔的猫1981

已于 2024-09-08 10:20:24 修改

阅读量846

点赞数 28

分类专栏： java基础文章标签： java 开发语言

于 2024-09-07 08:49:17 首次发布

本文链接：https://blog.csdn.net/sadfasdfsafadsa/article/details/141957479

版权

java基础专栏收录该内容

37 篇文章 2 订阅

订阅专栏

运算符是编程语言中用于执行各种操作的特殊符号或关键字。它们用于处理变量和值，执行数学计算、逻辑运算、位运算和其他操作，以便编写复杂的程序。运算符允许程序员在代码中执行各种操作，从而实现所需的功能。

Java中的运算符分类

算术运算符

用于执行基本的数学运算，加法、减法、乘法、除法和取模（取余）等。例如，+ 表示加法运算，- 表示减法运算。

代码：

int a = 20;
int b = 10;
System.out.println(a + b); // 30
System.out.println(a - b); // 10
System.out.println(a * b); // 200
System.out.println(a / b); // 2
System.out.println(a % b); // 0 --->模运算相当于数学中除法的余数

1.都是二元运算符，使用时必须要有左右两个操作数
2.int / int 结果还是int类型，而且会向下取整**

int a = 3;
int b = 2;
// 在数学中应该是1.5 但是在Java中输出结果为1 会向下取整，即小数点之后全部舍弃掉了
System.out.println(a / b);
// 如果要得到数学中的结果，可以使用如下方式
double d = a*1.0 / b;
System.out.println(d);

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

int a = 1;
int b = 0;
System.out.println(a / b)
// 运行结果
Exception in thread "main" java.lang.ArithmeticException: / by zero
at Test.main(Test.java:5)

增量运算符 += -= *= %=

注意：

++、--它们在变量的位置不同是有一定的区别的。

举个例子

①++在变量后面的例子：

public class Demo {
    public static void main(String[] args) {
        int a = 15;
        //当++在后：表示：先运算、后自增
        int b = a++;
        System.out.println("b = " + b);
        System.out.println("a = " + a);
    }
}

②++在变量前的例子：

public class Demo {
    public static void main(String[] args) {
        int a = 15;
        //当++在后：表示：先运算、后自增
        int b = ++a;
        System.out.println("b = " + b);
        System.out.println("a = " + a);
    }
}

int a = 3;
int b = a++;
System.out.println(a);//4
System.out.println(b);//3

int c = 3;
int d = --c;
System.out.println(c);//2
System.out.println(d);//2

后置++或者–都是先使用变量原来的值，然后在加加或者减减。

前置++或者–都是先加加或者减减，在使用变量的加加减减的值。

注意事项：

如果单独使用，前置和后置没有区别。
只有变量才能使用自增或者自减运算符。
自增/自减运算可以用于整数类型 byte、short、int、long，浮点类型 float、double，以及字符串类型 char。
在 Java 1.5 以上版本中，自增/自减运算可以用于基本类型对应的包装器类 Byte、Short、Integer、Long、Float、Double 和 Character。
]

运算结果的类型

表达式的自动类型转化在表达式中小范围类型的变量，会自动转化成较大范围的类型，再参与运算

表达式的最终结果类型由表达式的最高类型决定的 double

–当操作数中有double类型时 float–当操作数中，没有double,有float类型时 long–当操作数中,没有float,有long类型时 int–当操作数中没有long,有int

当操作数没有int，有byte，short，char时会提升为int，也就是直接转换成int类型参与运算

赋值运算符

赋值运算符的作用是将等号右边的值赋给等号左边，右边的值可以是一个数值、变量或者表达式的。注意:在java中判断相等==，不是用=

public class Main {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        a += b; // a = a + b, 现在a等于30
        System.out.println("Value of a after operation : " + a);
 
        int c = 10;
        c -= b; // c = c - b, 现在c等于-10
        System.out.println("Value of c after operation : " + c);
 
        int d = 10;
        d *= b; // d = d * b, 现在d等于200
        System.out.println("Value of d after operation : " + d);
 
        int e = 10;
        e /= b; // e = e / b, 现在e等于0，因为10除以20得到的是0，结果是int类型，所以结果为0
        System.out.println("Value of e after operation : " + e);
 
        int f = 10;
        f %= b; // f = f % b, 现在f等于10，因为10除以20的余数为10
        System.out.println("Value of f after operation : " + f);
    }
}

关系运算符

用于比较两个值的关系，返回布尔值。

也可称为“比较运算符”，用于用来比较判断两个变量或常量的大小。运算结果是 boolean 型。当运算符对应的关系成立时，运算结果是 true，否则是 false。

int num1 = 3;
int num2 = 0;
System.out.println(num1 == num2);//false
System.out.println(num1 != num2);//true
System.out.println(num1 < num2);//false
System.out.println(num1 > num2);//true
System.out.println(num1 <= num2);//false
System.out.println(num1 >= num2);//true

逻辑运算符

逻辑运算符是把多个条件放在一起运算，连接多个boolean值，最后返回boolean值

1.逻辑与 &&

语法规则：表达式1 && 表达式2，左右表达式必须是boolean类型的结果。

相当于现实生活中的且，比如：如果是学生，并且带有学生证才可以享受半票。

两个表达式都为真，结果才是真，只要有一个是假，结果就是假。

int a = 1;
int b = 2;
System.out.println(a == 1 && b == 2); // 左为真 且 右为真 则结果为真

2.逻辑或 ||

语法规则：表达式1 || 表达式2，左右表达式必须是boolean类型的结果。

相当于现实生活中的或，比如：买房子交钱时，全款或者按揭都可以，如果全款或者按揭，房子都是你的，

否则站一边去。

int a = 1;
int b = 2;
System.out.println(a == 1 || b == 2); // 左为真 且 右为真 则结果为真

注意：&& 和 || 都是短路逻辑运算符

int a = 1;
int b = 2;
System.out.println(a++ > 0 || b++ >0);//true
system.out.println(a);//2
system.out.println(b);//2

短路逻辑运算符：||如果左边为真，右边不执行。

int a = 1;
int b = 2;
System.out.println(a++ < 0 && b++ >0);//true
system.out.println(a);//2
system.out.println(b);//2

3.逻辑非 !

语法规则：! 表达式

真变假，假变真。

int a = 1;
System.out.println(!(a == 1)); // a == 1 为true，取个非就是false
System.out.println(!(a != 1)); // a != 1 为false，取个非就是true

三目运算符

条件运算符只有一个:

表达式1 ? 表达式2 : 表达式3

当表达式1 的值为 true 时, 整个表达式的值为表达式2 的值;

当表达式1 的值为 false 时, 整个表达式的值为表达式3 的值.

也是 Java 中唯一的一个三目运算符, 是条件判断语句的简化写法

// 求两个整数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;

注意事项：

表达式2和表达式3的结果要是同类型的，除非能发生类型隐式类型转换
表达式不能单独存在，其产生的结果必须要被使用

十二、运算符优先级
在一条表达式中，各个运算符可以混合起来进行运算，但是运算符的优先级不同，比如：* 和 / 的优先级要高于 +和 - ，有些情况下稍不注意，可能就会造成很大的麻烦。

只需要记住：在一条表达式中，各个运算符可以混合起来进行运算，但是运算符的优先级不同，比如：* 和 / 的优先级要高于 +和 - ，有些情况下稍不注意，可能就会造成很大的麻烦。

位运算符用于执行位级别的操作。

&：按位与
|：按位或
^：按位异或
~：按位非
<<：左移
>>：带符号右移
>>>：无符号右移
1.按位与 &
对两个操作数的每个位执行与操作，只有两个操作数的对应位都为1时，结果位才为1。例如，1101 & 1010 的结果是 1000。

2.按位或 |
对两个操作数的每个位执行或操作，只要两个操作数的对应位中有一个为1，结果位就为1。例如，1101 | 1010 的结果是 1111。

3.按位异或 ^
对两个操作数的每个位执行异或操作，只有两个操作数的对应位不相同时，结果位才为1。例如，1101 ^ 1010 的结果是 0111。

重要结论：

a ^ 0等于a。
a^a等于0.
4.按位非~
对单个操作数的每个位执行非操作，将0变为1，将1变为0。例如，~1101 的结果是 0010。

5.左移<<
将操作数的二进制位向左移动指定的位数，右侧用0填充。例如，5 << 2 的结果是 20，因为 5 的二进制表示是 101，左移两位后变成 10100，即十进制的 20。左移几位就是相当于乘以2^n。

6.带符号右移>>
将操作数的二进制位向右移动指定的位数，根据最高位的值用0或1填充。这保持了有符号数的符号（正负号）。例如，-8 >> 1 的结果是 -4，因为 -8 的二进制表示是 11111111111111111111111111111000，带符号右移1位后变成 11111111111111111111111111111100，即十进制的 -4。

7.无符号右移>>>
类似于带符号右移，但不保留符号位，始终用0填充。这适用于无符号整数。例如，-8 >>> 1 的结果是 2147483644，因为它的二进制表示与带符号右移相同，但不考虑符号。

注意事项：

左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.
右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.
由于计算机计算移位效率高于计算乘除, 当某个代码正好乘除 2 的N次方的时候可以用移位运算代替.
移动负数位或者移位位数过大都没有意义.