Java_运算符
- Java提供运算符来操纵变量。运算符是特殊的符号,用来表示数据的运算,赋值和比较等
- 常见的运算符有:
算术运算符,关系运算符,位运算符,逻辑运算符,赋值运算符,其他运算符
算术运算符
-
算术运算符用在数学表达式中,作用和数学中的作用一样。
A=10,B=20操作符 描述 例子 + 加法-相加运算符两侧的值 A + B等于30 - 减法-相加运算符两侧的值 A - B等于10 * 乘法-相乘操作符两侧的值 A * B等于200 / 除法-左操作数除以右操作数 B / A等于2 % 取余-左操作数除以右操作数的余数 B % A等于0 ++ 自增-操作数的值+1 B++或者++B等于21 – 自减-操作数的值-1 B–或者–B等于19 -
如果对负数取模,可以把模数负号忽略不计;
5%-2=1 -
如果被取模数是负数不可以忽略负号,此外,取模运算结果不一定总是整数
-5%-=-1 -
对于除号
/，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。例如：int x=3510;x=x/1000*1000; x=3000
字符串连接运算符
-
"
+"可以实现字符串的连接，还可以实现字符串与其他数据类型“相连”。public class Test { public static void main(String[] args) { int a = 10; int b = 20; int c = 25; int d = 25; System.out.println("a + b = " + (a + b) ); System.out.println("a - b = " + (a - b) ); System.out.println("a * b = " + (a * b) ); System.out.println("b / a = " + (b / a) ); System.out.println("b % a = " + (b % a) ); System.out.println("c % a = " + (c % a) ); System.out.println("a++ = " + (a++) ); System.out.println("a-- = " + (a--) ); // 查看 d++ 与 ++d 的不同 System.out.println("d++ = " + (d++) ); System.out.println("++d = " + (++d) ); } }
关系运算符：A=10,B=20
-
所有以关系运算符作为最终运算的表达式结果一定是boolean类型
运算符 描述 例子 == 检查如果两个操作数的值是否相等，如果相等则条件为真 (A==B)为假 ！= 检查如果两个操作数的值是否相等，如果值不相等则条件为真 (A!=B)为真 > 检查左操作数的值是否大于右操作数的值，如果是则条件为真 (A>B)为假 < 检查左操作数的值是否小于右操作数的值，如果是则条件为真 (A<B)为真 >= 检查左操作数的值是否大于或等于右操作数的值，如果相等则条件为真 (A>=B)为假 <= 检查左操作数的值是否小于或等于右操作数的值，如果相等则条件为真 (A<=B)为假
public class Test {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("a == b = " + (a == b) ); // false
System.out.println("a != b = " + (a != b) ); // true
System.out.println("a > b = " + (a > b) ); // false
System.out.println("a < b = " + (a < b) ); // true
System.out.println("b >= a = " + (b >= a) ); // true
System.out.println("b <= a = " + (b <= a) ); // false
}
}
自增&&自减运算符
自增（++）自减（--）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数。
| 运算符 | 描述 |
|---|---|
前缀自增自减法(++a,--a): | 先进行自增或者自减运算，再进行表达式运算 |
后缀自增自减法(a++,a--): | 先进行表达式运算，再进行自增或者自减运算 |
public class Test{
public static void main(String[] args){
int a = 3;//定义一个变量；
//int b = ++a;// 拆分运算过程为:` a=a+1=4; b=a=4, 最后结果为b=4,a=4`
//System.out.println("a="+a);4
//System.out.println("b="+b);4
int c = a++; //拆分运算过程为:` c=a=3,a=a+1=4; 最后结果为c=3,a=4`
System.out.println("a="+a); //4
System.out.println("c="+c); //3
}
public class Test{
public static void main(String[] args){
int a = 5;//定义一个变量；
int b = 5;
int x = 2*++a;
int y = 2*b++;
System.out.println("自增运算符前缀运算后a="+a+",x="+x); // a=6 x =12
System.out.println("自增运算符后缀运算后b="+b+",y="+y); // b=6 y =10
}
}
逻辑运算符
- 逻辑运算符的操作数均为boolean表达式。
| 运算符 | 描述 |
|---|---|
&& 表示逻辑与运算符 | 相当于"并且"，同真为真，一假为假 |
| ll 表示逻辑或运算符 | 相当于"并且"，同真为真，一假为假 |
! 表示逻辑非运算符 | 表示逻辑非运算符 |
逻辑运算符的图解
| b1 | b2 | b1&&b2 | b1ll b2 | !b1 |
|---|---|---|---|---|
| false | false | false | false | true |
| false | true | false | true | true |
| true | false | false | true | false |
| true | true | true | true | false |
public class Test {
public static void main(String[] args) {
boolean a = true;
boolean b = false;
System.out.println("a && b = " + (a&&b));
System.out.println("a || b = " + (a||b) );
System.out.println("!(a && b) = " + !(a && b));
}
}
- 逻辑运算符的短路特性:
- 对于逻辑与运算符来说，若第一个表达式为假则结果为假，此时跳过第二个表达式；
- 对于逻辑或运算符来说，若第一个表达式为真则结果为真，此时跳过第二个表达式；
条件/三目运算符
-
条件表达式? 表达式1: 表达式2，判断条件表达式是否成立，若成立则执行表达式1，否则执行表达式2
-
比较两个数最大值
public static void main(String[] args) { // write your code here int a = 30; int b = 20; // 数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B; // 判断a > b是否成立，如果成立将a的值赋值给max；如果不成立将b的值赋值给max。二者选其一 int max = a > b ? a : b; // 最大值的变量 System.out.println("最大值：" + max); // 30 System.out.println(a > b ? a : b); // 正确写法！ } -
比较三个数最大值
public static void main(String[] args) { // write your code here int a = 30; int b = 20; int c = 10; // 数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B; // 判断a > b是否成立，如果成立将a的值赋值给max；如果不成立将b的值赋值给max。二者选其一 int temp = a > b ? a : b; // 两个最大值的变量 int max = temp>c?temp:c; // 比较三个数最大值 System.out.println("最大值：" + max); // 30 System.out.println(a > b ? a : b); // 正确写法！ }
赋值运算符
| 运算符 | 描述 |
|---|---|
= 表示赋值运算符, 当=两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。 | C = A + B将把A + B得到的值赋给C |
+ = 加和赋值操作符 | C + = A等价于C = C + A |
- = 减和赋值操作符 | C - = A等价于C = C - A |
* = 乘和赋值操作符 | C * = A等价于C = C * A |
/ = 除和赋值操作符 | C / = A等价于C = C / A |
％= 取模和赋值操作符 | C％= A等价于C = C％A |
移位运算符
| 移位运算符 | 描述 |
|---|---|
| << 左移运算符 | 用于将数据的二进制位向左移动，右边使用0补充 |
| >> 右移运算符 | 用于将数据的二进制位向右移动，左边使用符号位补充 |
| >>> 表示逻辑右移运算符 | 用于将数据的二进制位向右移动，左边使用0补充 |
位运算符
- Java定义了位运算符,应用于整数类型(int),长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。
- 位运算符作用在所有的位上，并且按位运算。假设
a = 60，b = 13;
| 位运算符 | 描述 |
|---|---|
| & 表示按位与运算符 | 按照二进制位进行与运算，同1为1，一0为0 |
| l 表示按位与运算符 | 按照二进制位进行或运算，一1为1，同0为0 |
| ~ 表示按位取反运算符 | 按照二进制位进行取反，1为0，0为1 |
| ^ 表示按位异或运算符 | 按照二进制位进行异或运算，同为0，不同为1 |
二进制格式表示将如下：
A = 0011 1100
B = 0000 1101
A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011
A << 2得到240，即 1111 0000
A >> 2得到15即 1111
A>>>2得到15即
public class Test {
public static void main(String[] args) {
int a = 60; /* 60 = 0011 1100 */
int b = 13; /* 13 = 0000 1101 */
int c = 0;
c = a & b; /* 12 = 0000 1100 */
System.out.println("a & b = " + c );
c = a | b; /* 61 = 0011 1101 */
System.out.println("a | b = " + c );
c = a ^ b; /* 49 = 0011 0001 */
System.out.println("a ^ b = " + c );
c = ~a; /*-61 = 1100 0011 */
System.out.println("~a = " + c );
c = a << 2; /* 240 = 1111 0000 */
System.out.println("a << 2 = " + c );
c = a >> 2; /* 15 = 1111 */
System.out.println("a >> 2 = " + c );
c = a >>> 2; /* 15 = 0000 1111 */
System.out.println("a >>> 2 = " + c );
}
}
Java_运算符优先级
- x = 7 + 3 * 2;这里x得到13，而不是20，因为乘法运算符比加法运算符有较高的优先级，所以先计算3 * 2得到6，然后再加7。
- 具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。
Java_instanceof 运算符
| 样例 | 含义 |
|---|---|
| x instanceof A | 检验x是否为类A的对象，返回值为boolean型。 要求x所属的类与类A必须是子类和父类的关系，否则编译错误。 |
| x instanceof A | 如果x属于类A的子类B，x instanceof A值也为true。 |
-
instanceof运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。String name = "James"; boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真 -
注意:如果被比较的对象兼容于右侧类型,该运算符仍然返回true。
class Vehicle {} public class Car extends Vehicle { public static void main(String[] args){ Vehicle a = new Car(); boolean result = a instanceof Car; System.out.println( result); } }
Java_自动类型转换
-
自动类型转换:整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。
低 ------------------------------------> 高 byte,short,char—> int —> long—> float —> double -
有多种类型的数据进行混合运算时,系统首先自动将所有数据类型转换成容量最大的那种数据类型,然后再进行计算
-
byte,short,char之间不会相互转换,这三种数据类型在计算时会首先转换为int类型 -
不能对
boolean类型进行类型转换。 -
不能把对象类型转换成不相关类的对象。
-
在把
容量大的类型转换为容量小的类型时必须使用强制类型转换。 -
转换过程中可能导致溢出或损失精度
-
当把任何基本数据类型的值和字符串
(String)进行连接时(+),基本数据类型的值将自动转化为字符串(String)类型 -
自动类型转换必须满足转换前的数据类型的位数要低于转换后的数据类型,例如:
short数据类型的位数为16位，就可以自动转换位数为32的int类型，``float数据类型的位数为32，可以自动转换为64位的double类型。 -
高位数转向低位数的数据类型时则会出现溢出的情况
Java_强制类型转换
- 强制类型转换:将容量大的数据类型转换为容量小的数据类型,使用时要加上强制转换符:
(转换类型),但是可能会造成精度降低的问题，如 float f=(float)12.0; int a=(int)1200L - 通常,
字符串不能直接转换为基本类型,但是通过基本类型对应的包装类则可以实现把字符串转换为基本类型 String a = "43"; int b = Integer.parseInt(a);boolean类型不能转换为其他数据类型
public class Test{
public static void main(String[] args){
int i1 = 123;
byte b = (byte) i1; //强制类型转换为byte
System.out.println("int强制类型转换为byte后的值等于" + b);
}
}
Java_隐含强制类型转换
- 整数的默认类型是
int - 浮点类型不存在隐含的强制类型转换的情况,因为定义
float类型时必须在数字后面上 F 或者 f。
216
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
