Java 笔记 06：基本运算符概述，分类，和使用方式

蟾宫曲

已于 2024-04-24 11:14:56 修改

阅读量1.1k

点赞数 22

分类专栏： Java 基础篇文章标签： java 开发语言运算符 intellij-idea 笔记

于 2024-04-24 11:10:45 首次发布

本文链接：https://blog.csdn.net/sareur_1879/article/details/138152654

版权

Java 基础篇专栏收录该内容

18 篇文章 1 订阅

订阅专栏

一、前言

记录时间 [2024-04-24]

系列文章简摘：
Java 笔记 01：Java 概述，MarkDown 常用语法整理
 Java 笔记 03：Java 基础知识，使用 IDEA 创建 Java 项目、设置注释颜色，以及自动生成 JavaDoc
Java 笔记 04：Java 数据类型基础，数据类型转换，及其相关场景拓展
 Java 笔记 05：变量和常量相关知识，Java 编程的命名规范

更多 Java 相关文章，请参考上面专栏哦。

本文对 Java 中的基本运算符进行整理，介绍优先级的简便使用方式，并按照操作数的不同进行分类，大致可分为一元 / 二元 / 三元运算符。

二、基本运算符

在 Java 中，基本运算符是用于执行各种算术、比较和逻辑操作的符号。以下是 Java中的一些常用基本运算符。

关于运算符的优先级：括号（）最高，不确定就加括号，又清楚又方便。

算术运算符
赋值运算符
关系运算符
逻辑运算符
位运算符
条件运算符
扩展赋值运算符

算术运算符		       	 +，-，*，/，%，++，--
赋值运算符		       	 =（ a = 10，把 10 赋值给 a ）
关系运算符		       	 >，<，>=，<=，==，!=，instanceof
逻辑运算符		       	 &&，||，!（与或非）
位运算符		       	  	&，|，^，~，>>，<<，>>>（了解！！！）
条件运算符		      	  ? :
扩展赋值运算符			+=，-=，*=，/=

1. 算术运算符

常规操作

算术运算符用于执行算术操作，如加、减、乘、除等。

+：加法
-：减法
*：乘法
/：除法
%：取模（取余）

例如，在 Java 中使用算术运算符：

public class Demo01 {

    public static void main(String[] args) {

        // 二元运算符
        // Ctrl + D : 复制当前行到下一行
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;

        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        
        // 强制转换 int 为 double 类型，否则数据会丢失精度
        System.out.println(a/(double)b);
        
        // 取余，模运算
        System.out.println(c%a);   //  c/a   25/10 = 2 ... 5
    }

}

出现 long 类型

另外，当出现 long 类型时：

在 Java 中，当进行数学运算时，如果涉及到不同类型的整数，例如 int 和 long，Java 会自动将较小类型 int 的操作数提升为较大类型 long，然后执行运算，输出结果为 long 类型。

但是，如果没有出现 long 类型，不管是 int、short 还是其他的，输出结果为 int 类型。

例如下面的案例中，a 为 long 类型，所以 a+b+c+d 的值为 long 类型，其余为 int 类型。

public class Demo02 {

    public static void main(String[] args) {

        long a = 123123123123123L;
        int b = 123;
        short c = 10;
        byte d = 8;

//        有 Long 为 Long，其他为 int
        System.out.println(a+b+c+d);    //Long
        System.out.println(b+c+d);      //int
        System.out.println(c+d);        //int

    }

}

2. 赋值运算符

赋值运算符用于赋值操作，主要有如下这些：

=：赋值
+=：加后赋值
-=：减后赋值
*=：乘后赋值
/=：除后赋值
%=：取模后赋值

例如：

// x += 5; 等同于 x = x + 5; 结果是15

int x = 10;
x += 5;

3. 关系运算符

关系运算符用于比较两个值，关系运算符一般结合 if 语句使用。

==：等于
!=：不等于
>：大于
<：小于
>=：大于或等于
<=：小于或等于

例如：

public class Demo03 {

    public static void main(String[] args) {

        /*
        关系运算返回结果为 布尔值
        正确	true
        错误	false
        */

        int a = 10;
        int b = 20;
        int c = 21;

        // 判断 a>b 的结果，并输出
        System.out.println(a>b);	// 大于 false
        
        System.out.println(a<b);	// 小于 true
        System.out.println(a==b);	// 等于 false
        System.out.println(a!=b);	// 不等于 true

    }

}

4. 逻辑运算符

与或非

逻辑运算符用于组合多个布尔表达式，主要有如下这些：

&&：逻辑与（AND），两个变量都为真，结果才为 true
||：逻辑或（OR），两个变量有一个为真时，结果为 true
!：逻辑非（NOT），如果是真，则为假；如果是假则为真

例如：

boolean isTrue = true;
boolean isFalse = false;

// 逻辑与（AND）
boolean result = isTrue && isFalse; // false

// 逻辑或（OR）
boolean anotherResult = isTrue || isFalse; // true

// 逻辑非（NOT）
boolean negation = !isTrue; // false

短路运算

在逻辑运算中，存在一种短路运算的情况：短路运算指的是在逻辑表达式的求值过程中，如果结果已经可以确定，那么就不再计算后续的表达式。

例如，对于 AND 运算符 &&：

如果第一个操作数为 false，那么整个表达式的结果就是 false，此时后续的操作数不会被计算。
如果第一个操作数为 true，那么才会计算第二个操作数。

同样地，对于 OR 运算符 ||：

如果第一个操作数为 true，那么整个表达式的结果就是 true，此时后续的操作数不会被计算。
如果第一个操作数为 false，那么才会计算第二个操作数。

这种行为可以帮助我们更有效地编写代码，避免不必要的计算，提高代码的性能。

我们可以通过代码来感受一下这种短路运算的情况：

/*
	短路运算：
	在判断 "a && b" 的 true or false 时，
    如果 a为假，则判断结束，
    a && b 结果为假，且 b 不执行。

    在此例子中，c==5，故 c<4 为 false
    判断 c++<4 是否执行，
    主要看该句执行后，c 的值是否发生改变（c 有没有自增），
    如果 c==5 ，则没执行；如果 c==6 ，则执行了
    结果： c++<4 没有执行
*/
public class Demo05 {

    public static void main(String[] args) {
        
        // 短路运算
        int c = 5;
        boolean d = (c<4) && (c++<4);
        System.out.println("d = " + d);
        System.out.println("c = " + c);

    }
}

5. 位运算符

位运算符（Bitwise Operators），用于在位级别上操作整数值的各个位，是二进制层面的。

&：按位与，0 & 0 == 0；0 & 1 == 0；1 & 1 == 1；
|：按位或，0 | 0 == 0；0 | 1 == 1；1 | 1 == 1；
^：按位异或，0 ^ 0 == 0；0 ^ 1 == 1；1 ^ 1 == 0；
~：按位非，~1 == 0；~0 == 1；
<<：左移
>>：右移
>>>：无符号右移

例如：

int p = 5; 							// 二进制表示为 0101
int q = 3; 							// 二进制表示为 0011
int andResult = p & q; 				// 按位与  0001 (1)
int orResult = p | q; 				// 按位或  0111 (7)
int xorResult = p ^ q; 				// 按位异或 0110 (6)
int leftShiftResult = p << 1; 		// 左移 1 位 1010 (10)
int rightShiftResult = p >> 1; 		// 右移 1 位 0010 (2)

位运算的效率：

在大多数计算机架构中，位操作可以在硬件级别上实现，因此它们通常比乘法和除法运算更快。

在计算机编程中，某些情况下，使用位操作（如左移 << 和右移 >>）可以更高效地实现乘法和除法的功能。

例如，计算 2 * 8

2 * 8 可以表示为 2 * 2 * 2 * 2；
左移 << 相当于乘以 2，所以左移一位相当于乘以 2，左移两位相当于乘以 4，以此类推；
右移 >> 相当于除以 2，所以右移一位相当于除以 2，右移两位相当于除以 4，以此类推；
所以 2 * 8 相当于 2 左移 3 位。

/*
    0000 0000       0
    0000 0001       1
    0000 0010       2
    0000 0011       3
    0000 0100       4
    0000 1000       8
    0001 0000       16
*/

System.out.println(2<<3);   //16

三、按操作数分类

基本运算符也可以按照操作数的不同进行分类，大致可分为一元 / 二元 / 三元运算符。

1. 一元运算符

在 Java 中，一元运算符是只需要一个操作数来执行操作的运算符，以下是一些常用的一元运算符。

递增和递减运算符

递增 ++：将操作数的值增加 1。
递减 --：将操作数的值减少 1。

int a = 5;
a++;  // 等同于 a = a + 1; a 的值变为 6
a--;  // 等同于 a = a - 1; a 的值变为 5

自增自减很重要，通过下面这个案例来具体分析下吧。

public class Demo04 {

    public static void main(String[] args) {

        //  ++    --  自增，自减   一元运算符
        int a = 5;

        int b = a++;    //执行完这行代码后，先给 b 赋值，再自增
        // a++  a = a+1
        System.out.println("a = " + a);

        // ++a  a = a+1
        int c = ++a;   //执行完这行代码后，先自增，再给 c 赋值

        System.out.println("a = " + a);
        System.out.println("b = " + b);
        System.out.println("c = " + c);

    }

}

重点查看这两句：

// 执行完这行代码后，先给 b 赋值为 a 的当前值， a 再自增
int b = a++;

// 执行完这行代码后，a 先自增，再给 c 赋值为 a 的新值
int c = ++a;

假设 a 的初始值是 5，执行 int b = a++; 后，b 的值是 5（因为此时 a 还是 5）。

然后 a 的值被增加到 6，执行 int c = ++a; 后，a 的值被增加到 7，c 的值现在是 7。

正负号运算符

正号 +：表示一个正数。
负号 -：表示一个负数。

int b = -10;  // b 的值为 -10
int c = +10;  // c 的值为 10

按位非运算符

按位非 ~：按位取反操作数的每一位。

int d = 5;     // 二进制表示为 0101
int e = ~d;    // 二进制表示为 1010, 十进制表示为 -6

逻辑非运算符

逻辑非 !：反转操作数的布尔值。

boolean p = true;
boolean q = !p;  // q 的值为 false

强制类型转换

强制类型转换 (type)：将一个数据类型转换为另一个数据类型。

int f = 100;
byte g = (byte) f;  // 显式类型转换，可能导致数据丢失

2. 二元运算符

在 Java 中，二元运算符是需要两个操作数来执行操作的运算符。

常见算术运算符

+：加法
-：减法
*：乘法
/：除法
%：取模（取余）

int a = 10;
int b = 5;
int sum = a + b;  			// 加：sum = 15
int difference = a - b;  	// 减：difference = 5
int product = a * b;  		// 乘：product = 50
int quotient = a / b;  		// 除：quotient = 2
int remainder = a % b;  	// 模：remainder = 0

常见关系运算符

==：等于
!=：不等于
>：大于
<：小于
>=：大于或等于
<=：小于或等于

boolean isEqual = (a == b);  		// false
boolean isNotEqual = (a != b);  	// true
boolean isGreater = (a > b);  		// true
boolean isLess = (a < b);  			// false

逻辑与 / 或运算符

&&：逻辑与（AND）
||：逻辑或（OR）

boolean andResult = (a > 0) && (b < 10);  		// true
boolean orResult = (a < 0) || (b > 10);  		// false

常见赋值运算符

=：赋值
+=：加并赋值
-=：减并赋值
*=：乘并赋值
/=：除并赋值
%=：取模并赋值

a += 5;  	// a = a + 5;
b -= 2;  	// b = b - 2;

按位与 / 或 / 异或运算符

&：按位与
|：按位或
^：按位异或

int bitwiseAnd = a & b;		// 按位与
int bitwiseOr = a | b;		// 按位或
int bitwiseXor = a ^ b;		// 按位异或

3. 三元运算符

三元运算符是一种特殊的条件运算符，它由三部分组成：一个条件表达式，一个真值表达式和一个假值表达式。

三元运算符是一种非常便捷的方式来根据一个条件选择两个可能的值之一。它可以替代简单的 if-else 结构，使代码更简洁。但要注意，过度使用三元运算符可能会使代码变得难以理解，因此应谨慎使用。

在 Java 中，三元运算符的语法是：

condition：一个布尔表达式
如果 condition 为 true，则返回 trueExpression 的值
如果 condition 为 false，则返回 falseExpression 的值

例如：在这个例子中，因为 a > b 是 false，所以选择了 b 作为结果。

// condition ? trueExpression : falseExpression

// a > b 为 false，返回 b
int a = 5;
int b = 10;
int a > b ? a : b;

四、总结

本文对 Java 中的基本运算符进行整理，介绍优先级的简便使用方式，并按照操作数的不同进行分类，大致可分为一元 / 二元 / 三元运算符。

一些参考资料

狂神说 Java 零基础：https://www.bilibili.com/video/BV12J41137hu/
TIOBE 编程语言走势： https://www.tiobe.com/tiobe-index/
Typora 官网：https://www.typoraio.cn/
Oracle 官网：https://www.oracle.com/
Notepad++ 下载地址：https://notepad-plus.en.softonic.com/
IDEA 官网：https://www.jetbrains.com.cn/idea/