07、Java 中的运算符

最新推荐文章于 2022-09-19 10:33:32 发布

Little Tomato

最新推荐文章于 2022-09-19 10:33:32 发布

阅读量191

点赞数

分类专栏： Java基础

本文链接：https://blog.csdn.net/weixin_46136492/article/details/119706841

版权

Java基础专栏收录该内容

8 篇文章 0 订阅

订阅专栏

文章目录

1、算术运算符

算术运算符	名称	举例
+	加法	`10 + 11 = 21`
-	加法（数值取反）	`15 - 10 = 5` 或者 `double d = 4.5; c = -b`
*	乘法	`10 * 10 = 100`
/	除法	`100 / 10 = 10`
%	求余数	`15 % 4 = 3`
++	自增1	`int index = 5; index++;`
–	自减1	`int index = 5; index--;`

public static void main(String[] args) {
    int numOne = 10, numTwo = 15;

    System.out.println(numOne + numTwo);    // 25
    System.out.println(numOne - numTwo);    // -5
    System.out.println(-(numOne - numTwo));    // 5
    System.out.println(numOne * numTwo);    // 150
    System.out.println(numTwo / numOne);    // 1
    System.out.println(numTwo % numOne);    // 10
}

注意：当加号 + 出现在字符串之间，那么它充当的是字符串连接符，而不是加法运算中的加号 +

什么时候求和？什么时候进行字符串的拼接操作呢？

当 + 运算符两边都是数字类型的时候，求和。
当 + 运算符两边的“任意一边”是字符串类型的时候，那么这个 + 会进行字符串拼接操作。

public static void main(String[] args) {    
    System.out.println(100 + 100);	// 加法运算	200
    
    // 当一个表达式有多个加号的时候，遵循自左向右的顺序依次执行。(除非额外添加了小括号,小括号的优先级高) 
	// 加号进行字符串拼接操作	String：201011
    System.out.println("String：" + 2010 + 11);	
    // 加号进行字符串拼接操作	String：2021
    System.out.println("String：" + (2010 + 11));	
    // 加号进行字符串拼接操作	2021String
    System.out.println(2010 + 11 + "String");	
    
    // String 字符串型变量
    String str = "NUMBER" + "_NUMBER";
    System.out.println(str);    // 加号进行字符串拼接操作 NUMBER_NUMBER
}

++/-- 可以出现在变量前也可以出现在变量后，在 ++/-- 执行结束之后，变量一定会自加（自减）1。

++/-- 出现在变量前和变量后的区别。

++/-- 出现在变量后，会先做赋值运算，再自加（自减）1。
++/-- 出现在变量前，会先进行自加（自减）1运算，然后再赋值。

public static void main(String[] args) {
    int i = 10;
    int k = i++;
    System.out.println(k);	// 10
    System.out.println(k);	//	11
    
    int x = 100;
    int y = ++x;
    System.out.println(x);	// 101
    System.out.println(y);	// 101
    
    int a = 5;
    int b = a--;
    System.out.println(a);	// 4
    System.out.println(b);	// 5
    
    int c = 50;
    int d = --c;
    System.out.println(c);	// 49
    System.out.println(d);	// 49
}

2、关系运算符

运算符	含义	举例
`>`	大于运算符	`2 > 3` 返回 `false`
`>=`	大于或等于	`4 >= 3` 返回 `true`
`<`	小于	`2 < 3` 返回 `true`
`<=`	小于或等于	`2 <= 1` 返回 `false`
`==`	等于	`2 == 3` 返回 `false`
`!=`	不等于	`2 != 3` 返回 `true`

所有的关系型运算符的结果都是布尔类型，不是true就是false，不可能存在其它值。

Java语言中，= 表示赋值运算符， == 关系运算符，判断是否相等。

运算符存在两个符号的话，两个符号之间不能存在空格。

public static void main(String[] args) {
    int a = 10;
    int b = 10;
    System.out.println(a > b);	// false
    System.out.println(a >= b);	// true
    System.out.println(a < b);	// false
    System.out.println(a <= b);	// true
    System.out.println(a == b);	// true
    System.out.println(a != b);	// false
}

3、逻辑运算符

运算符	用法	含义
`&&`	`a && b`	短路与
`\|\|`	`a \|\| b`	短路或
`!`	`!a`	逻辑非（取反）
`\|`	`a \| b`	逻辑或（或者）
`&`	`a & b`	逻辑与（并且）

逻辑运算符两边要求都是布尔类型，并且最终的运算结果也是布尔类型。

对于逻辑与 & 运算符来说，只要有一边是 false ，结果就是 false ，只有两边同时为 true ，结果才是 true 。

public static void main(String[] args) {
    int a = 10;
    int b = 10;
    System.out.println(a > b & a == b);	// false
    System.out.println(a >= b & a == b);	// true
    System.out.println(a > b & a < b);	// false
}

对于逻辑或 | 来说，只要有一边是 true ，结果就是 true ，只有两边同时为 false 时结果才是 false 。

public static void main(String[] args) {
    int a = 10;
    int b = 10;
    System.out.println(a > b | a == b);	// true
    System.out.println(a >= b | a == b);	// true
    System.out.println(a > b | a < b);	// false
}

逻辑非 ! 就是对现有的结果取反。

public static void main(String[] args) {
    int a = 10;
    int b = 10;
    System.out.println(!(a == b));	// false
    System.out.println(!(a > b));	// true
}

短路与 && 和逻辑 && 有什么区别？

结果无区别，但是短路与或发生短路现象。

System.out.println(true & true);	// true
System.out.println(true && true);	// true

什么是短路现象，什么时候发生“短路”？

a > b && a < b 左边表达式执行了，但是右边表达式不执行，这种情况通常发生在左边为 false 的时候。

int x = 10;
int y = 11;
System.out.println(x > y & x < y++);
System.out.println(y);	// 12

int a = 10;
int b = 11;
System.out.println(a > b && a < b);
System.out.println(b);	// 11

短路或 || 只要有一边是 true ，结果就是 true ，左边表达式为 true 的时候，会发生短路。

注意：短路与和短路或能够采用更加优化的计算方式，在实际开发中建议优先考虑短路与和短路或

4、赋值运算符

赋值运算符包括 基本赋值运算符 和 扩展赋值运算符

基本赋值运算符：=
扩展赋值运算符：+= -= *= /= %=

public static void main(String[] args) {
    int x = 10;
    x += 10;	// 等同于 x = x + 10;
    Syste,.out.println(x);	// 20
    
    x -= 10;	// 等同于 x = x - 10;
    System.out.println(x);	// 10
    
    x *= 10;
    System.out.println(x);	// 100
    
    x /= 10;
    System.out.println(x);	// 10
    
    x %= 3;
    System.out.println(x);	// 1
}

x = x + 10 和 x += 10 的区别：使用扩展运算符的时候，永远都不会改变运算结果类型。

public static void main(String[] args) {
    byte x = 100;
    System.out.println(b);	// x
    
    // 错误: 不兼容的类型: 从int转换到byte可能会有损失
    // x = x + 1;	
    
    x += 1;	// x = (byte) (x + 1)
    System.out.println(x);	// 101
}

5、条件运算符（三目运算符）

语法格式：布尔表达式 ? 表达式1 : 表达式2

布尔表达式为 true 时，表达式1的执行结果作为整个表达式的结果
布尔表达式为 false 时，表达式2的执行结果作为整个表达式的结果

public static void main(String[] args) {
    int i = 100;
    
    char sex = i == 100 ? '男' : '女';
    System.out.println(sex);	// 男
    
	char c = i < 100 ? '男' : '女';
    System.out.println(c);	// 女
}

6、位运算符

关于二进制、原码、反码、补码和字符编码相关知识


`<<` (左位移运算符)	空位补0，被移除的高位丢弃
`>>` (右位移运算符)	被移除的二进制最高位是0，右移后，空缺补零，最高位是1，最高位补1。
`&` (按位与运算符（AND)	任何二进制位和0进行&运算，结果是0；和1进行&运算结果是原值。
`\|` (按位或运算符（OR)	任何二进制位和0进行 `\|` 运算，结果是原值；和1进行`\|`运算结果是1
`^` (按位异或运算符（XOP）)	任何相同二进制位进行 `^` 运算，结果是0；不相同二进制位`^`运算结果是1
`~` (按位取反运算符（NOT）)	只对一个操作数进行运算，将操作数二进制中的 1 改为 0，0 改为 1

6.1、`&` 按位与运算符（AND）

任何二进制位和0进行&运算，结果是0；和1进行&运算结果是原值。

/*
	00000000 10010110	--> 150
  &
	00000000 00000011	--> 3
----------------------------------
	00000000 00000010	---> 2
*/
public static void main(String[] args) {
    int x = 150, y = 3;
    System.out.println(x & y);	// 2
}

6.2、`|` 按位或运算符（OR）

任何二进制位和0进行 | 运算，结果是原值；和1进行|运算结果是1

/*
	00000000 10010110	--->	150
  |
	00000000 00000011	--->	3
----------------------------------------
	00000000 10010111	--->	151
*/
public static void main(String[] args) {
    int x = 150, y = 2;
    System.out.println(x | y);	// 151
}

6.3、`^` 按位异或运算符（XOP）

任何相同二进制位进行 ^ 运算，结果是0；不相同二进制位^运算结果是1

/*
	00000000 10010110	--->	150
  ^
	00000000 00000011	--->	3
--------------------------------------
	00000000 10010101	---> 	149
*/
public static void main(String[] agrs) {
    int x = 150, y = 2;
    System.out.println(x | y);	// 149
}

6.4、`~` 按位取反运算符（NOT）

只对一个操作数进行运算，将操作数二进制中的 1 改为 0，0 改为 1

/*
	00000000 00000000 00000000 000000011	--->	3
--------------------------------------
	11111111 11111111 11111111 111111100	--->	6377292
*/
public static void main(String[] agrs) {
    System.out.printf("%d \n", ~3);	// -4
}

编译程序，发现输出的结果是 -4，而不是6377292，这是因为取反之后的结果是十六进制数，而在上面的程序中使用 %d 将输出转换为了十进制数。

public static void main(String[] agrs) {
    System.out.printf("%x \n", ~10);
}

可以看到输出结果为 fffffffc，将它转换为二进制是 11111111 11111111 11111111 11111100。这个二进制数的最高位为 1，表示这个数为负数。除最高位外，按位取反再加 1，即得到二进制原码 10000000 00000000 00000000 00000100，用十进制数表示即为 -4。

6.4、`<<` 左位移运算符

按二进制形式把所有的数字向左移动对应的位数，高位移出（舍弃），低位的空位补零

public static void main(String[] args) {
    System.out.ptintln(1 << 1);
    // 0000 0000 0000 0001
    // 0000 0000 0000 0010
    // 左移结果为2
}

6.5、`>>` 右位移运算符

将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。

public static void main(String[] args) {
    System.out.println(3 >> 1);	
    // 0000 0000 0000 0011
    // 0000 0000 0000 0001 
    // 3右移一位结果为：1
    System.out.println(-3 >> 1);
    // 原码：1000 0011
    // 反码：1111 1100
    // 补码：1111 1101
    // 右移1:1111 1110
    // 反码：1111 1101
    // 原码：1000 0010
    // 右移一位结果为：-2
}

原创博主：Little Tomcat
博主原文链接：https://mp.weixin.qq.com/s/6zkhksxoD7c0zTUukbU6eA

Little Tomato

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
07、Java 中的运算符

文章目录1、算术运算符2、关系运算符3、逻辑运算符4、赋值运算符5、条件运算符（三目运算符）6、位运算符6.1、`&` 按位与运算符（AND）6.2、`|` 按位或运算符（OR）6.3、`^` 按位异或运算符（XOP）6.4、`~` 按位取反运算符（NOT）6.4、`<<` 左位移运算符6.5、`>>` 右位移运算符1、算术运算符算术运算符名称举例+加法10 + 11 = 21-加法（数值取反）15 - 10 = 5 或者 double
复制链接

扫一扫