java双目if java双目运算符是什么意思

转载

charlesc 2023-08-22 12:46:14

文章标签 java双目if Java System 运算符操作数 文章分类 Java 后端开发

写程序的目的就是管理和运算数据。可以对数据进行什么样的运算。

“运算符”

概念：
操作数：参与各种预算的数据。
表达式：使用运算符将操作数有机的结合在一起的整体被称为表达式。1+1 就是表达式。 1 和 1 是操作数。 + 是运算符。

一元运算符：只有一个操作数的运算符。也成为单目运算符。
二元运算符：需要两个操作数的运算符。双目运算符。
三元运算符：需要三个操作数的运算符。三目运算符。

返回值：操作数和表达式的返回值。
程序中参与的任何运算的数据，都是数据的返回值参与的。
返回值：操作数参与运算的值。表达式计算之后得到的值。
a = a + 1
Math.random()

"算术运算符"

1：+ 加法
既是一元运算符，也是二元运算符。
+2 ：正数一元
实现两个操作数相加的效果。2+2 二元

2：- 减法
既是一元运算符，也是二元运算符。
-2 负数一元
实现两个操作数相减的效果。2-2 二元

3：* 乘法
二元运算符
实现了两个操作数相乘的效果。
正负号的规则同数学中一样一样的。

4：/ 除法
二元运算符
实现了两个数相除的效果。
正负号的规则同数学中一样一样的。

“注意：如果操作数都是整数，那么结果也是整数，余数直接被砍掉。如果有一个操作数是浮点数，那么结果是浮点数。”

5：% 取余
二元运算符
a%b：a 除以 b 得到的余数。
结果的符号位和左边的操作数相同。

6：++ 自增运算符
一元运算符。只能对变量做操作。
作用：最变量做自增一的操作。
有两种模式：前缀和后缀。

区别：
后缀模式：先返回，后自增。
前缀模式：先自增，后返回。

7：-- 自减运算符
一元运算符。只能对变量做操作。
作用：最变量做自减一的操作。
有两种模式：前缀和后缀。

区别：
后缀模式：先返回，后自减。
前缀模式：先自减，后返回。

"赋值运算符"

1：=
二元运算符。
作用：将右边的表达式的返回值赋值给左边的变量。
右边的表达式：常量、变量、常量+变量的表达式。—右值
左边：只能是变量，或者是终态变量的赋初值。—左值

在所有的运算符中，结合的优先级最低，最后做赋值操作。

复合赋值运算符。
+=
-=
*=
/=
%= …

&&=
||=
&=
|=
^=

特点：
1：使用复合赋值运算符生成的字节码文件要比常规的实现要小一点。相对来说更节约内存。
2：隐含了一个强制类型转换，被强制转换的类型为左边变量的类型。

//复合赋值运算符

public class Test1{
	public static void main(String[] args){
		int value = 10;
		
//value = value + 1;
// value ++;
//复合赋值运算符	value += 1;

//value = value + 5;
//自身+5 再赋值给自身
value += 5;
		
System.out.println("value = "+value);
// //自身-5 再赋值给自身
value -= 5;
// //自身*5 再赋值给自身
value *= 5;
value /= 5;
value %= 5;

  }
}

"关系运算符"

都是二元运算符，一共有6个。

大于：> 左边的操作数是否大于右边的操作数
小于：< 左边的操作数是否小于右边的操作数
大于等于： >= 左边的操作数是否大于等于右边的操作数
小于等于：<= 左边的操作数是否小于等于右边的操作数
等于：== 左边的操作数是否等于右边的操作数
不等于：!= 左边的操作数是否不等于右边的操作数

关系表达式的返回值是 boolean 值，如果关系是成立的，返回true ，否则返回false。

关于关系运算的操作数的类型问题：
基本数据类型中所有的数值类型 byte short int long float double char 都可以进行大小的比较和是否相等的比较。
boolean 类型：只能进行是否相等的比较。

//复合赋值运算符

public class Test1{
	public static void main(String[] args){
		int value = 10;
		
//value = value + 1;
// value ++;
//复合赋值运算符	value += 1;

//value = value + 5;
//自身+5 再赋值给自身
value += 5;
		
System.out.println("value = "+value);
// //自身-5 再赋值给自身
value -= 5;
// //自身*5 再赋值给自身
value *= 5;
value /= 5;
value %= 5;

  }
}

"逻辑运算符"

参与逻辑运算的操作数必须是布尔值 true or false，逻辑表达式的结果是布尔值。

逻辑与：&
逻辑或：|
逻辑异或：^
逻辑非：!

短路与: &&
短路或：||

//复合赋值运算符
public class TestLogic{
	public static void main(String[] args){
		//逻辑与 &  一个二元运算符  规律：两个操作数都是true 真 时候，结果为true，有一个操作数是falsse 结果就是false  并且的意思。


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

// 逻辑或 |  一个二元运算符  规律： 两个操作数有一个为true ，返回值为true 否则            为false。
		System.out.println(true | false)；	//true
		System.out.println(false | true)；	//true
		System.out.println(true | true)；     //true
		System.out.println(false | false)；  //false


System.out.println();
		// 逻辑异或 ^  一个二元运算符  规律：两个操作数相异为true，相同为false。
		System.out.println(true ^ false)；    //true
		System.out.println(false ^ true)；	//true
		System.out.println(true ^ true)；	    //false
		System.out.println(false ^ false)；	//false
		System.out.println();
		//逻辑非  逻辑反 !  一元运算符。 规律：true 变false false 变true
		System.out.println(!true)；	//false
		System.out.println(!false)；	//true
		System.out.println()；
		
//短路与 && 二元运算符  规律：同逻辑与
		System.out.println(true && false)；	//false
		System.out.println(false && true)；	//false
		System.out.println(true && true)；	//true
		System.out.println(false && false)；//false
		
System.out.println();
		区别 逻辑与 和 短路与的区别： 逻辑与运算符，再进行运算的时候，任何情况下，所有的操作数都会被计算，并参与逻辑运算。
		//短路与，如果前面的操作数结果为false，那么就不会再计算后面操作数的返回值了。后面的操作数就不会再参与运算了。效率比逻辑与的效率要高。优先选择使用。
		int value = 9;
		System.out.println(false && (++value >= 10))；//false
		System.out.println("value = "+value)；
		
System.out.println();
		// 短路或 ||  一个二元运算符  规律： 两个操作数有一个为true ，返回值为true 否则为false。  或者的意思。
		// 区别：短路或，如果前面的一个操作数为true，那么后面的操作数就不再进行运算。直接返回整个表达式的值为true。优先使用短路或。
		System.out.println(true || false)；	//true
		System.out.println(false || true)；	//true
		System.out.println(true || true)；	    //true
		System.out.println(false || false)；	//false
		
**"位运算符"**

直接对底层的二进制位做操作的，效率比较高。

对二进制位的运算符，只能对整数类型进行操作。char。浮点数不支持。

结果都是整数。

位运算符：
1：按位与  	&
2：按位或 	| 
3：按位异或 	^
4: 按位取反 	~
5: 带符号右移 >>
6：左移 	<<
7: 无符号右移	>>>

//复合赋值运算符
import java.util.Random；
public class TestBit{
	public static void main(String[] args){
		//按位与   &  二元运算符。  低位要对齐，规则：对应的位上有0则0 全1 则1.
		System.out.println(5&6)；
		System.out.println(4&11)；
		//应用：可以使用& 实现 将某个数的 某一部分二进制位 表示的数值求出来。
		System.out.println(0x1a&0xf)；
		//按位或  |  二元运算符。  低位对齐。规则：对应的位上有1 则 1 全0 则0.
		System.out.println(5|6)；//7
		//应用：如果两个操作数对应的位上没有全 1 的情况  那么两个数按位或的结果和相加的结果一致。
		//按位异或  ^  二元运算符 。低位对齐，，规则：对应的位相异为 1，相同为0.
		System.out.println(0^10)；//10
		//特点：如果一个数 先后异或了同一个数2次，那么结果还是它自身。
		int num = 19；
		int key = 211；
		System.out.println(num ^ key)；
		System.out.println(num ^ key ^ key)；
		//简单的加密的算法。 
		char c0 = '我'；
		char c1 = '喜'；
		char c2 = '欢'；
		char c3 = '你'；
		//密钥
		key = 15210;
		//加密
		c0 ^= key；
		c1 ^= key；
		c2 ^= key；
		c3 ^= key；
		System.out.print("我向你表白的密文："+c0+c1+c2+c3)；
		//解密
		c0 ^= key；
		c1 ^= key；
		c2 ^= key；
		c3 ^= key；
		System.out.print("\n我向你表白的明文："+c0+c1+c2+c3)；
		System.out.println()；
		//按位取反 ~  一元运算符  规则：所有的二进制位 0变1  1变0
		System.out.println(~0)；//-1
		
//带符号右移 >>   二元运算符  规则 ：右移动n位  低n 位被移走，高n位空出来，补符号位，整数补0  负数 补1。
		System.out.println(0b1010 >> 1)；//10-->5
		System.out.println(0b101 >> 1)；//5-->2
		System.out.println(0b1111 >> 2)；//15-->3


//应用：在某些情况下，右移动 n 位 ，可以实现除以2的n次幂的功能。 移位的效率高于除的效率。
		int value = 123;
		System.out.println(value >> 4)；
		System.out.println(value / 16)；
		//-5 : 1000 0101  ----> 1111 1011>> 4 --> 1111 1111
		System.out.println(-5 >> 14)；
	
//左移 <<  二元运算符。 规则：高位被移走，低位补0
		System.out.println(1 << 1)；//1-->2
		System.out.println(1 << 2)；//1-->4
		System.out.println(1 << 3)；//1-->8
		System.out.println(1 << 4)；//1-->16
		System.out.println(0b1000000000000000000000001 << 4)；//从负数变成 了正数。

//应用：在某些情况下，左移n位可以替代乘以2的n次幂的功能。
		

//无符号右移  >>>  二元操作符  规则：右移动n位  低n 位被移走，高n位空出来，不管正数负数高位都补0.
		//应用：得到一个正整数。
		//创建用与生成随机数的对象
		Random random = new Random()；
		//得到一个随机的整数，这个整数均匀的分配在int 的取值范围内。
		num = random.nextInt()；
		System.out.println("num = "+num)；
		final int MAX = 21；
		final int MIN = 10；
		num >>>= 1；
		System.out.println("随机的，很大的正整数 num = "+num)；
		//num = num >>> 1；
		//控制区间
		num = num % (MAX-MIN) + MIN；
		System.out.println(" num = "+num)；
			num = (int)(Math.random()*(MAX-MIN)+MIN)；
		System.out.println(" num = "+num)；
		num = (random.nextInt() >>> 1)%(MAX-MIN) + MIN；
		System.out.println(" num = "+num)；
}
}

"条件运算符"

三目运算符，三个操作数。 java 唯一的一个三目运算符。

语法格式：

布尔表达式 ? 表达式-1 ：表达式-2；

执行过程：
布尔表达式的返回值是一个 boolean 值，如果该表达式返回 true，执行表达式-1，并将表达式-1的返回值，作为整个三目表达式的返回值返回。如果返回false，那么跳过表达式-1，执行表达式-2，并将表达式-2 的返回值作为整个三目表达式的返回值返回。

注意：表达式-1 的返回值和表达式-2 的返回值的类型必须兼容。

//求2个随机数，范围[10,20],使用两种随机数获得方式获得，然后打印随机数的值，然后将比较大的值求的，并最后打印。
import java.util.Random；
public class TestThree{
		public static void main(String[] args){
		final int MAX = 21；
		final int MIN = 10；
		//随机数-1
		int value1 = (int)(Math.random()*(MAX-MIN)+MIN)；
		//创建用于生成随机数的对象
		Random ran = new Random()；
		//随机数-2
		int value2 = (ran.nextInt() >>> 1)%(MAX-MIN)+MIN；
		//随机数-3
		int value3 = (int)(Math.random()*(MAX-MIN)+MIN)；
		
System.out.println("得到的随机数为：value1 = "+value1 + "\tvalue2 = "+value2+ "\tvalue3 = "+value3)；
		
//将比较大的赋值给max
		// int max = value1 > value2 ? value1 ： value2
		// max = max >  value3 ? max ：value3
		//嵌套的三目
		int max = value1 > value2 ?    (value1 > value3 ? value1 ：value3)   ：   (value2 > value3 ? value2 ： value3)；
			System.out.println("max = "+max)；

//思考：如果是三个随机数，四个随机数，如何求最大值呢？
//四个数求最大值：先求两个随机数的最大值 max1，然后再求另外两个随机数的最大值max2，然后比较 max1，和max2就可以了。
}

"运算符的优先级"

运算符优先级的基本的规则：

1：乘除大于加减。

2：一元运算符大于二元运算符的优先级。二元大于三元运算符优先级。

3：赋值运算符最后做。

4：实在不行用小括号。

java双目if java双目运算符是什么意思_System