Java中的运算符_java运算符

Java中常用运算符

1、 赋值运算符

（1）赋值运算符“=”用于给变量指定变量值。
（2）复合赋值运算符：+=、-=、*=、/=、%=
例子：a+=3;------->a=a+3;

public class Test {

	public static void main(String[] args) {
		int a;
		a=1;//此时a输出为1
		a+=3;//此时a输出为4
		a-=1;//此时a输出为3
		a*=2;//此时a输出为6
		a/=3;//此时a输出为2
		a%=3;//此时a输出为2
		System.out.println(a);
		
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2、算术运算符

（1）算术运算符包括:+、-、*、/、%、++、–
（2）对于除法运算符，如果两个操作数均是整数，结果也是整数，会舍弃小数部分；如果两个操作数中有一个是浮点数，将进行自动类型转换，结果也是浮点数，保留小数部分。
（3）对于取模运算符（取余运算符）/，如果两个操作数均是整数，结果也是整数；如果两个操作数中有一个是浮点数，结果也是浮点数，保留小数部分。
（4）自增运算符有i++、++i两种使用方式，它们的特点是都相当于i=i+1;不同点是i++是先进行表达式运算再加1，而++i是先加1再进行表达式运算。

public class Test{
	public static void main(String[] args) {
		int i=0;
		int a;
		a=i++;//先将i的值赋值给a，i再自增
		System.out.println(a);//a输出为0
		a=++i;//i先自增再把自增后的值赋值给a
		System.out.println(a);//a输出为2
	}

}
1
2
3
4
5
6
7
8
9
10
11

3、关系运算符（比较运算符）

（1）关系运算符用于比较两个变量或者常量的大小，运算结果是布尔值true或false。

（2）Java中共有6个关系运算符，分别是==、!=、>、<、>=、<=。

（3）>、<、>=、<=只支持数值类型的比较。

（4）==、!=支持所有数据类型的比较，包括数值类型、布尔类型、引用类型。

（5）>、<、>=、<=优先级别高于==、!=。

public class Test {

	public static void main(String[] args) {
		/*
		 * 关系运算符：> >= < <= == !=
		 * 关系运算符的结果是布尔值，要么为true要么为false
		 * >、<、>=、<= 运算符的优先级别高于==、!=
		 * >、<、>=、<=运算符只支持数值类型的数据比较
		 * 
		 * 
		 */
		int num1 = 100;
		int num2 =200;
		
		boolean result1 =num1>num2;
		System.out.println("num1>num2:"+result1);
		
		System.out.println("num1>=num2:"+(num1>=num2));
		System.out.println("num1<num2:"+(num1<num2));
		System.out.println("num1<=num2:"+(num1<=num2));
		System.out.println("num1=num2:"+(num1==num2));
		System.out.println("num1!=num2:"+(num1!=num2));

	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

4、逻辑运算符

（1）逻辑运算符用于对两个布尔型操作数进行运算，其结果还是布尔值。
（2）Java中共有6个逻辑运算符，分别是&（逻辑与）、|（逻辑或）、^（逻辑异或）、!（逻辑反、逻辑非）、&&（短路与）、||（短路或）

public class Test {

	public static void main(String[] args) {
		/*
		 * 逻辑运算符：&(单与) &&(短路与) |(单或) ||(短路或) !(非)
		 * 参与逻辑运算的表达式需要时布尔类型
		 * 逻辑运算的结果是布尔值，要么为true要么为false
		 * 
		 */
		
		int a =100;
		int b =200;
		// true & true --->true
		//true && true --->true
		boolean result1 =a<b & b>a;
		System.out.println(result1);
		System.out.println("true&true:"+(true&true));
		System.out.println("true&&true:"+(true&&true));
		
		//true & false --->false
		//true && false --->false
		System.out.println("true&false:"+(true&false));
		System.out.println("true&&false:"+(true&&false));
		
		//false & true -->false
		//false && true-->false
		System.out.println("false&true:"+(false&true));
		System.out.println("false&&true:"+(false&&true));
		
		//false & false-->false
		//fasle && false -->false
		System.out.println("false&false:"+(false&false));
		System.out.println("false&&false:"+(false&&false));
		/*
		 * 根据上面的运算结果得知：
		 * 	&和&&的运算规律是一样的，只有当& &&左右两边的表达式同时为true，& &&的运算结果才为true
		 * 
		 */
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

public class Test {

	public static void main(String[] args) {
		/*
		 * 逻辑运算符：&(单与) &&(短路与) |(单或) ||(短路或) !(非)
		 * 参与逻辑运算的表达式需要时布尔类型
		 * 逻辑运算的结果是布尔值，要么为true要么为false
		 * 
		 */
		
		int a =100;
		int b =200;
		// true | true --->true
		//true || true --->true
		boolean result1 =a<b | b>a;
		System.out.println(result1);
		System.out.println("true|true:"+(true|true));
		System.out.println("true||true:"+(true||true));
		
		//true | false --->true
		//true || false --->true
		System.out.println("true|false:"+(true|false));
		System.out.println("true||false:"+(true||false));
		
		//false | true -->true
		//false || true-->true
		System.out.println("false|true:"+(false|true));
		System.out.println("false||true:"+(false||true));
		
		//false | false-->false
		//fasle || false -->false
		System.out.println("false|false:"+(false|false));
		System.out.println("false||false:"+(false||false));
		/*
		 * 根据上面的运算结果得知：
		 * 	|和||的运算规律是一样，只要| ||两边的表达式中有一个为true，| ||的运算结果就为true
		 * 
		 */
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

（3）逻辑运算符运算规律

（4）优先级别：“!”>“&”>“^”>“|”>“&&”>“||”
（5）&和&&的区别：当&&的左侧为false时，将不会计算其右侧的表达式，即左false则false；无论任何情况，“&”两侧的表达式都会参与计算。

public class Test {

	public static void main(String[] args) {
		/*
		 * &&和&的区别
		 * 	&&具有短路功能，当&&左边的表达式结果为false的时候，&&右边表达式不需要进行计算
		 * 	&没有短路功能，不管&左边的表达式结果为true还是false，&右边的表达式都需要进行计算
		 */
		
		int x=8;
		int y=9;
		System.out.println((++x==y)&&(++x!=y));//true
		System.out.println(x);//10
		
		int a=8;
		int b=9;
		System.out.println( (++a!=b)&&(++a==b));//false
		System.out.println(a);//9
		
		int m=8;
		int n=9;
		System.out.println( (++m!=n)&(++m==n));//false
		System.out.println(m);//10
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

（6）|和||的区别：当||的左侧为true时，将不会计算其右侧的表达式，即左true则true；无论任何情况，“|”两侧的表达式都会参与计算。

public class Test{

	public static void main(String[] args) {
		/*
		 * ||和|的区别
		 * 	||具有短路功能，当||左边的表达式为true的时候，||右边表达式不需要进行计算
		 * 	|没有短路功能，不管|左边的表达式结果为true还是false，|右边的表达式都需要进行计算
		 *  
		 */
		
		int x=8;
		int y=9;
		System.out.println((++x==y)||(++x!=y));//true
		System.out.println(x);//9
		
		int a=8;
		int b=9;
		System.out.println( (++a!=b)||(++a==b));//false
		System.out.println(a);//10
		
		int m=8;
		int n=9;
		System.out.println( (++m==n)|(++m==n));//true
		System.out.println(m);//10
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

5、条件运算符

（1）条件运算符是Java中唯一的需要3个操作数的运算符。
（2）语法格式：
条件?表达式1:表达式2;
（3）运算规律：
首先对条件进行判断，如果其值为true，则返回表达式1的值；如果条件值为false，则返回表达式2的值。

public class Test {

	public static void main(String[] args) {
		/*
		 * 条件运算符（三目运算符/三元运算符）：
		 * 	语法结构：
		 * 		条件?表达式1:表达式2;
		 * 	执行规律：
		 * 		如果条件为true，执行表达式1
		 * 		如果条件为false，执行表达式2
		 */
		
		int num1=1000;
		int num2 =200;
		
		int max =num1>num2?num1:num2;
		System.out.println("最大值："+max);
		
		int min =num1>num2?num2:num1;
		System.out.println("最小值："+min);
		
		int min2 =num1<num2?num1:num2;
		System.out.println("最小值："+min2);

	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

（4）条件运算符的嵌套
条件?(条件?表达式1:表达式2):(条件?表达式1:表达式2);

public class Test {
	public static void main(String[] args) {
		int num1=2;
		int num2=3;
		int num3=4;
		int max=num1>num2?(num1>num3?num1:num3):(num2>num3?num2:num3);
		System.out.println(max);
	}

}
1
2
3
4
5
6
7
8
9
10

Java运算符的优先级

（1）Java中的各种运算符都有自己的优先级和结合性。
（2）优先级：在表达式运算中的运算顺序。优先级越高，在表达式中运算顺序越靠前。
（3）结合性：运算的方向，大多数运算符的结合性都是从左向右，即从左向右依次进行运算。
（4）优先级别最低的是赋值运算符，其次是条件运算符。
（5）单目运算符包括!、~、++、–，优先级别高。
（6）可以通过“()”控制表达式的运算顺序，“()”优先级最高。
（7）总体而言：优先顺序为算术运算符>关系运算符>逻辑运算符
（8）结合性从右向左的只有赋值运算符、三目运算符和单目运算符（一个操作数）。
（9）运算符的优先级如下所示：