java三元运算详解
运算符
2.1 运算符概念
运算符是用来计算数据的指令。数据可以是常量，也可以是变量。被运算符操作的数成为操作数。
Int x = 3;
Int y = 4;
Int z = x + y
2.2 算数运算符
将操作数参与数学计算(通常为数学计算)
| 运算符 |
运算规则 |
范例 |
结果 |
| + |
正号 |
+3 |
3 |
| + |
加 |
2+3 |
5 |
| + |
连接字符串 |
“中”+“国” |
“中国” |
| - |
负号 |
int a=3;-a |
-3 |
| - |
减 |
3-1 |
2 |
| * |
乘 |
2*3 |
6 |
| / |
除 |
5/2 |
2 |
| % |
取模(余数) |
5%2 |
1 |
| ++ |
自增 |
int a=1;a++/++a |
2 |
| -- |
自减 |
int b=3;a--/--a |
2 |
注意：
-
加法运算符在连接字符串时要注意，只有直接与字符串相加才会转成字符串。
-
除法“/”当两边为整数时，取整数部分，舍余数。当两边为浮点型时，按正常规则相除。
-
“%”为整除取余符号，小数取余没有意义。取余结果的符号与被取余数的符号相同。
-
得到的是两个相除数据的余数。
-
用处: 判断两个数据是否整除。
-
-
整数做被除数，0不能做除数，否则报错。
-
小数做被除数，整除0结果为Infinity，对0取模结果为NaN
-
自增与自减
单独使用：
前置与后置效果相同，均为直接+1或-1
混合使用：
自增（++）：将变量的值加1，分前缀式（如++i）和后缀式（如i++）。前缀式是先加1再使用；后缀式是先使用再加1。
自减（--）：将变量的值减1，分前缀式（如--i）和后缀式（如i--）。前缀式是先减1再使用；后缀式是先使用再减1。
自增与自减运算符还遵循以下规律：
1. 可以用于整数类型byte、short、int、long，浮点类型float、double，以及字符串类型char。
2. 在Java5.0及以上版本中，它们可以用于基本类型对应的包装器类Byte、Short、Integer、Long、Float、Double、Character。
3. 它们的运算结果的类型与被运算的变量的类型相同。
赋值运算符
为变量赋值的运算符
| 运算符 |
运算规则 |
范例 |
结果 |
| = |
赋值 |
int a=2 |
2 |
| += |
加后赋值 |
int a=2，a+=2 |
4 |
| -= |
减后赋值 |
int a=2，a-=2 |
0 |
| *= |
乘后赋值 |
int a=2，a*=2 |
4 |
| /= |
整除后赋值 |
int a=2，a/=2 |
1 |
| %= |
取模后赋值 |
int a=2，a%=2 |
0 |
注意：
-
诸如+=这样形式的赋值运算符，会将结果自动强转成等号左边的数据类型。
/*
赋值运算符:
=,+=,-=,*=,/=,%=
+=,-=,*=,/=,%=运算符的运算规则:
先将运算符两边进行+,-,*,/,%运算,在把结果赋值给左边的变量
+=,-=,*=,/=,%=注意事项: 运算符左边必须是一个变量
+=,-=,*=,/=,%=特点:隐含一个强制类型转换
*/
public class Demo06Operator{
public static void main(String[] args){
int a = 10;
a += 20;//相当于 a = a + 20;
System.out.println("a = " + a);
//5 += 6;//错误: 意外的类型,这里5的位置需要一个变量
byte b = 10;
//b = b + 100;// 错误: 可能损失精度
//b = (byte)(b + 100);
b += 100;//+=隐含了一个强制类型转换 相当于b = (byte)(b + 100);
System.out.println("b = " + b);
}
}比较运算符
-
又叫关系运算符，即判断两个操作数的大小关系及是否相等关系，比较运算符的返回一定为布尔值。
| 运算符 |
运算规则 |
范例 |
结果 |
| == |
相等于 |
4==3 |
false |
| != |
不等于 |
4!=3 |
true |
| < |
小于 |
4<3 |
false |
| > |
大于 |
4>3 |
true |
| <= |
小于等于 |
4<=3 |
false |
| >= |
大于等于 |
4>=3 |
true |
-
==，!=，>，<，>=，<=
-
关系运算符的结果都是boolean型，也就是要么是true，要么是false。
-
注意事项
-
n 关系运算符“==”不能误写成“=” 。
public class Demo06Operator {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 10;
System.out.println(a == b);
System.out.println(a == c);
System.out.println("-----------------");
System.out.println(a != b);
System.out.println(a != c);
System.out.println("-----------------");
System.out.println(a > b);
System.out.println(a > c);
System.out.println("-----------------");
System.out.println(a >= b);
System.out.println(a >= c);
System.out.println("-----------------");
int x = 3;
int y = 4;
// System.out.println(x == y);
// System.out.println(x = y);// 把y赋值给x，把x的值输出
boolean bb = (x == y);
// 报错
// boolean cc = (x = y);
int cc = (x = y);
}
}
逻辑运算符
用于计算两个布尔值经过指定逻辑后的运算结果，结果同样是一个布尔值
| 运算符 |
运算规则 |
范例 |
结果 |
| & |
与(并且) |
false&true |
False |
| | |
或 |
false|true |
True |
| ^ |
异或 |
true^flase |
True |
| ! |
非(取反) |
!true |
Flase |
| && |
短路与 |
false&&true |
False |
| || |
短路或 |
true ||true |
True |
-
作用:逻辑运算符用于连接布尔型表达式，在Java中不可以写成3
-
基本使用: &(与),|(或),^(异或),!(非)
-
与：& 有false则false
-
或：| 有true则true
-
异或：^ 相同则false,不同则true
-
非：! true则false,false则true
-
public class Demo08Operator {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 30;
System.out.println((a > b) & (a > c));// false & false
System.out.println((a < b) & (a > c)); // true & false
System.out.println((a > b) & (a < c)); // false & true
System.out.println((a < b) & (a < c)); // true & true
System.out.println("---------------");
System.out.println((a > b) | (a > c));// false | false
System.out.println((a < b) | (a > c)); // true | false
System.out.println((a > b) | (a < c)); // false | true
System.out.println((a < b) | (a < c)); // true | true
System.out.println("---------------");
System.out.println((a > b) ^ (a > c));// false ^ false
System.out.println((a < b) ^ (a > c)); // true ^ false
System.out.println((a > b) ^ (a < c)); // false ^ true
System.out.println((a < b) ^ (a < c)); // true ^ true
System.out.println("---------------");
System.out.println((a > b)); // false
System.out.println(!(a > b)); // !false
System.out.println(!!(a > b)); // !!false
}
}
-
&&和&的区别
-
单&时，左边无论真假，右边都进行运算；
-
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
-
“|”和“||”的区别同理，双或时，左边为真，右边不参与运算。
-
三元运算符
接下来我们要学习的三元运算符与之前的运算符不同。之前学习的均为一元或者二元运算符。元即参与运算的数据。
格式：
-
(条件表达式)？表达式1：表达式2；
-
表达式：通俗的说，即通过使用运算符将操作数联系起来的式子，例如：
-
3+2，使用算数运算符将操作数联系起来，这种情况，我们称为算数表达式。
-
3>2，使用比较运算符（也称为条件运算符）将操作数联系起来，这种情况，我们称为条件表达式。
-
其他表达式，不再一一举例。
-
-
三元运算符运算规则：
先判断条件表达式的值，若为true，运算结果为表达式1；若为false，运算结果为表达式2。
注意：
-
三元运算符，最终一定会产生一个结果值，这个值必须被使用起来。
-
要么被运算符使用，要么被打印
/*
三元运算符:求两个数的最大值,判断两个数是否相等
格式:
(条件表达式) ? 表达式1 : 表达式2;
执行流程:
首先判断条件表达式是否成立
true:表达式1作为3元运算符的结果
false:表达式2作为3元运算符的结果
注意：
三元运算符，最终一定会产生一个结果值，这个值必须被使用起来。
要么被运算符使用，要么被打印
*/
public class Demo10Operator{
public static void main(String[] args){
int a = 10;
int b = 20;
int max = (a > b) ? 10 : 20;
System.out.println("max = " + max);
int c = 15;
int d = 10;
//System.out.println((c != d) ? "相等" : "不相等");
String s = (c != d) ? "相等" : "不相等";
System.out.println("s = " + s);
//(c != d) ? "相等" : "不相等";//错误: 不是语句
//3;//错误: 不是语句
}
}
运算符优先级
2.7.1 优先级概念
运算符运算的先后顺序，优先级越高(数字越小)，计算顺序越靠前。
2.7.2 优先级规则
优先级相同的情况下，按照从左到右的顺序依次运算
| 优先级 |
描述 |
运算符 |
| 1 |
括号 |
()、[] |
| 2 |
正负号 |
+、- |
| 3 |
自增自减，非 |
++、--、! |
| 4 |
乘除，取余 |
*、/、% |
| 5 |
加减 |
+、- |
| 6 |
移位运算 |
<<、>>、>>> |
| 7 |
大小关系 |
>、>=、<、<= |
| 8 |
相等关系 |
==、!= |
| 9 |
按位与 |
& |
| 10 |
按位异或 |
^ |
| 11 |
按位或 |
| |
| 12 |
逻辑与 |
&& |
| 13 |
逻辑或 |
|| |
| 14 |
条件运算 |
?: |
| 15 |
赋值运算 |
=、+=、-=、*=、/=、%= |
| 16 |
位赋值运算 |
&=、|=、<<=、>>=、 >>>= |
什么是三元运算符呢！无疑其操作元有三个。第一个是表达式，剩余两个是值，条件表达式为真时，取第一个值，为假时，取第二个值。
示例代码如下：
package cn.三元运算;
public class Test3 {
public static void main(String[] args) {
/*第一个是表达式，剩余两个是值，条件表达式为真时，
取第一个值，为假时，取第二个值。 */
int a=20;
int b=45;
boolean c=20<45?true:false;
//三元运算符的优先级高于赋值运算符，故第一个表达式为真，取第一个值，返回 a=true;
System.out.println("输出c的结果"+"..."+c);
//三元运算符用于做判断，其等价的if-else语句如下：
boolean c1;
if (20 < 45) {
c1 = true;
}else{
c1 = false;
}
//输出c1的结果
System.out.println("输出c1的结果"+"..."+c1);
}
}
三元运算符的优先级高于赋值运算符，故第一个表达式为真，取第一个值，返回 a=true;
三元运算符用于做判断，其等价的if-else语句如下：
boolean a;
if (20 < 45) {
a = true;
}else{
a = false;
}
简单实例三元运算代码二如下：
package cn.三元运算;
public class Test {
public static void main(String[] args) {
//定义int 类型的变量a
int a=20;
//定义int 类型的变量b
int b=20;
//使用三元运算符求两个最大值
System.out.println(a>b? a:b);
}
}
简单实例三元运算代码三如下：
package cn.三元运算;
public class Test2 {
public static void main(String[] args) {
//定义int 类型a
int a=19;
//定义string 类型b
String b="";
//使用三元运算符判断，如果a>20，b的值为大于 ，否则a<20的话，b的值为不大于
System.out.println(a>20?(b="大于"):(b="不大于"));
}
}
很多时候三元运算符可以和if-else语句进行互换，它们两个可以等价的实现判断的效果，但是三元运算符和if-else还是有不同之处的，下面我们来具体谈谈不同之处：
第一
两者之间对于返回值有不同的要求。三元运算符是必须要有返回值的要求，其运算后一定有一个返回值返回给开发人员使用，而if-else不一定有返回值，其执行结果可能是赋值语句或者是输出语句。
第二
两者的性能不同。三元运算符的运算性能高于if-else。
第三
两者使用范围不同，在ireport的一些动态执行的情况下，只能用三元运算符而不能用if-else语句，当然在大多数情况下两者是可以等价互换的
第四
两者的语言特性不同，三元运算符设计到一种双目运算符提升的特性，
所谓双目数值提升，在双目运算符java的开发环境下可以简单的理解为类型转换的问题。
1.如果定义了数据类型的变量和未定义数据类型的变量参与双目运算符的后双目运算，那么返回的结果就是范围大（精度高）的类型。
2.如果两个定义了数据类型的变量参与双目运算符的后双目运算，那么返回的结果就是范围大（精度高）的类型。
3.如果直接进行数值的比较，则自动转型为范围大（精度高）的类型。