Java学习第03天--运算符

java运算符

计算机的最基本用途之一就是执行数学运算，作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。我们可以把运算符分成以下几组：

• 算术运算符
• 关系运算符
• 位运算符
• 逻辑运算符
• 赋值运算符
• 其他运算符

运算符之算术运算符Arithmetic Operators

算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。下表列出了所有的算术运算符。

表格中的实例假设整数变量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（区别详见下文）

注意：

1. 除法操作两个操作数是整数时，结果也是整数，余数部分舍弃

  int x = 3500;

  System.out.println(x / 1000 * 1000);

2.% 操作获得的是除法操作的余数

  % 结果的符号取决于被模数，即 % 前面的数的符号决定了结果的正负

自增与自减运算符的介绍

++ ：自加

  放在变量前，先自增，再使用

  放在变量后，先使用，后自增

-- ：自减

  放在变量前，先自减，后使用

  放在变量后，先使用，后自减

注意：只能对变量使用

实例

public class selfAddMinus { public static void main ( String [] args ){ int a = 3 ; //定义一个变量； int b = ++ a ; //自增运算 int c = 3 ; int d = -- c ; //自减运算 System . out . println ( " 进行自增运算后的值等于 " + b ) ; System . out . println ( " 进行自减运算后的值等于 " + d ) ; } }

运行结果为：

进行自增运算后的值等于 4 进行自减运算后的值等于 2

解析：

• int b = ++a; 拆分运算过程为: a=a+1=4; b=a=4, 最后结果为b=4,a=4
• int d = --c; 拆分运算过程为: c=c-1=2; d=c=2, 最后结果为d=2,c=2

2、前缀自增自减法(++a,--a):  先进行自增或者自减运算，再进行表达式运算。

3、后缀自增自减法(a++,a--):  先进行表达式运算，再进行自增或者自减运算 实例：

实例

public class selfAddMinus { 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 ) ; System . out . println ( " 自增运算符后缀运算后b= " + b + " ,y= " + y ) ; } }

运行结果为：

自增运算符前缀运算后 a = 6 ， x = 12 自增运算符后缀运算后 b = 6 ， y = 10

字符串参与运算

1、两个操作数都是字符串

2、一个字符串一个变量

3、多个操作数

“+”除了字符串相拼接功能外，还能把非字符串转换成字符串，加字符串即可,如：String s = 5 + "";

实例：

赋值运算符Assignment Operators

下面是Java语言支持的赋值运算符：

操作符	描述	例子
=	简单的赋值运算符，将右操作数的值赋给左侧操作数	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
<< =	左移位赋值运算符	C << = 2等价于C = C << 2
>> =	右移位赋值运算符	C >> = 2等价于C = C >> 2
＆=	按位与赋值运算符	C＆= 2等价于C = C＆2
^ =	按位异或赋值操作符	C ^ = 2等价于C = C ^ 2
| =	按位或赋值操作符	C | = 2等价于C = C | 2

符号：

=， +=，-=，*=，/=，%=(扩展的赋值运算符)

示例：

  int a,b,c;  a=b=c=3;//支持连续赋值

  int a = 3;  

    a += 5;  //等同运算:a=a+5;

思考：

short s = 3;

s = s + 2; //1

s += 2; //2

s=s+2//编译失败，因为s会被提升为int类型，运算后的结果还是int类型。无法赋值给short类型。

s+=2//编译通过，因为+=运算符在给s赋值时，自动完成了强转操作。

比较运算符Compare Operators

1、操作数是常量，或变量，或表达式

2、比较运算符的结果是boolean型，要么是true，要么是false，常用作条件判断

3、比较运算符“==”不能误写成“=”

instanceof运算符

该运算符用于 操作对象实例 ，检查该对象是否是一个特定类型（类类型或接口类型）。

instanceof运算符使用格式如下：

( Object reference variable ) instanceof ( class / interface type )

如果运算符左侧变量所指的对象，是操作符右侧类或接口(class/interface)的一个对象，那么结果为真。

下面是一个例子：

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 ) ; } }

以上实例编译运行结果如下：

true

逻辑运算符Location Operators

下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假

操作符	描述	例子
&&	称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。	（A && B）为假。
| |	称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。	（A | | B）为真。
！	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。	！（A && B）为真。

实例

下面的简单示例程序演示了逻辑运算符。复制并粘贴下面的Java程序并保存为Test.java文件，然后编译并运行这个程序：

实例

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 )) ; } }

以上实例编译运行结果如下：

a && b = false a || b = true !( a && b ) = true

短路逻辑运算符

当使用与逻辑运算符时，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。

实例

public class LuoJi { public static void main ( String [] args ){ int a = 5 ; //定义一个变量； boolean b = ( a < 4 ) && ( a ++< 10 ) ; System . out . println ( " 使用短路逻辑运算符的结果为 " + b ) ; System . out . println ( " a的结果为 " + a ) ; } }

运行结果为：

使用短路逻辑运算符的结果为 false a 的结果为 5

解析：  该程序使用到了短路逻辑运算符(&&)，首先判断 a<4 的结果为 false，则 b 的结果必定是 false，所以不再执行第二个操作 a++<10 的判断，所以 a 的值为 5。

规律：

& ：只有两个操作数都是 true ，结果才是 true ，其余都是 false

| ：只要有一个操作数是 true ，结果就是 true ，其余都是 false

！：取反， true 变 false ， false 变 true

单操作数的只有一个！

异或的含义：求异，只有两个操作数不同，整个表达式才为 true

小结：

逻辑运算符的操作数都是布尔型表达式

 “&”和“&&”(短路与)的区别：

单&时，左边无论真假，右边都进行运算；

双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算，换句话说：右边只有在需要的时候，才参与运算

  “|”和“||”的区别同理，双或时，左边为真，右边不参与运算

异或( ^ )与或( | )的不同之处是：异或求的是异

或( | )：只要有个一为true，结果就为true

位运算符Bitwise Operators

位运算符
运算符	运算	范例
<<	左移	3 << 2 = 12 --> 3*2*2=12
>>	右移（带符号右移）	3 >> 1 = 1  --> 3/2=1
>>>	无符号右移	3 >>> 1 = 1 --> 3/2=1
&	与运算	6 & 3 = 2
|	或运算	6 | 3 = 7
^	异或运算	6 ^ 3 = 5
~	按位取反	~6 = -7

位运算是直接对二进制进行运算，所以必须知道操作数的二进制位才可以。

在不丢失有效位，或者更改符号位的情况下

<<：相当于乘以2的倍数

>>：相当于除以2的倍数

移n位，就是乘以或者除以2的n次幂。

位运算符的细节
<<	空位补0，被移除的高位丢弃，空缺位补0。
>>	被移位的二进制最高位是0，右移后，空缺位补0； 最高位是1，空缺位补1。
>>>	被移位二进制最高位无论是0或者是1，空缺位都用0补。
&	二进制位进行&运算，只有1&1时结果是1，否则是0;
|	二进制位进行 | 运算，只有0 | 0时结果是0，否则是1;
^	相同二进制位进行 ^ 运算，结果是0；1^1=0 , 0^0=0 不相同二进制位 ^ 运算结果是1。1^0=1 , 0^1=1

规律：

在不发生有效位丢失，且不改变符号位的情况下，左移运算相当于操作数乘以2的n次幂，右移相 当于操作数除以2的n次幂；

注意：

假设操作数为int型，移动的位数为x，若x超过32位，那么它实际移动的位数是x%32。例：2 << 34等价于 2 << 2。

练习代码：

/*

位运算的简单应用

1.不使用第三方变量交换两个变量的值

异或运算规律:

两个数异或的结果和其中的一个数再次异或,得到另一个数.

2.简单加密

*/

public class BitDemo3{

public static void main(String[] args){

//使用第三方变量交换两个变量的值

// int a = 10;

// int b = 20;

// System.out.println("交换前 :a = " + a + ",b = " + b);

// //定义临时变量

// int temp = a;

// a = b;

// b = temp;

// System.out.println("交换后 :a = " + a + ",b = " + b);

//两个数异或的结果和其中任意一个数再次异或,得到另外一个数

// int a = 20;

// int b = 10;

// System.out.println(a ^ b ^ a);// 相当于 b^a^a 将得到 b

//使用异或交换两个变量值

// int a = 10;

// int b = 20;

// System.out.println("交换前 :a = " + a + ",b = " + b);

// a = a ^ b;//

// b = a ^ b;//得到的是原来的a

// a = a ^ b;//用两个数异或的结果,和原来的a进行异或,得到原来的b

// System.out.println("交换后 :a = " + a + ",b = " + b);

//使用和的方式交换两个变量

// int a = 10;

// int b = 20;

// System.out.println("交换前 :a = " + a + ",b = " + b);

// a = a + b;

// b = a - b;

// a = a - b;

// System.out.println("交换后 :a = " + a + ",b = " + b);

//一条语句交换两个变量的值

// int a = 10;

// int b = 20;

// System.out.println("交换前 :a = " + a + ",b = " + b);

// b = (a + b) - (a = b);

// System.out.println("交换后 :a = " + a + ",b = " + b);

//简单加密

int m = 2000;

int key = 23;

m = m ^ key;

System.out.println(m);

System.out.println(m ^ key);

}

}

三元运算符Ternary Operators

格式：

（条件表达式）？表达式1：表达式2；

如果条件为true，整个表达式结果为表达式1；

如果条件为false，整个表达式结果为表达式2；

实例

Test.java 文件代码：

public class Test { public static void main ( String [] args ){ int a , b ; a = 10 ; // 如果 a 等于 1 成立，则设置 b 为 20，否则为 30 b = ( a == 1 ) ? 20 : 30 ; System . out . println ( " Value of b is : " + b ) ; // 如果 a 等于 10 成立，则设置 b 为 20，否则为 30 b = ( a == 10 ) ? 20 : 30 ; System . out . println ( " Value of b is : " + b ) ; } }

以上实例编译运行结果如下：

Value of b is : 30 Value of b is : 20

面试题：

下面语句的输出结果是？

   System.out.println(2>1?2:1.0);

答案：2.0

练习代码：

/*

三元运算符求三个数最大值

*/

public class TenaryDemo2{

public static void main(String[] args){

/*

int a = 70;

int b = 90;

int c = 30;

//先求前两个数的最大值（方法一）

// int m1 = (a > b)?a:b;

//在求三个数中的最大值

// int res = (m1 > c)?m1:c;

//三元运算符的嵌套（方法二）

int res = (a > b)?(a > c?a:c):(b > c?b:c);

System.out.println("三个数中的最大值是: " + res);

*/

System.out.println(2>1?2:1.0);//2.0,系统自动判断两个表达式的类型,并进行隐式转换

}

}