Java基础重温(三)运算符与表达式

最新推荐文章于 2018-10-15 16:29:00 发布

desmond_assis

最新推荐文章于 2018-10-15 16:29:00 发布

阅读量1k

点赞数

分类专栏： Java基础重温文章标签： java位运算 java运算符

本文链接：https://blog.csdn.net/firemaple_li/article/details/9104145

版权

Java基础重温专栏收录该内容

15 篇文章 0 订阅

订阅专栏

1.运算符的优先级和结合性

序列号	符号	名称	结合性(与操作数)	目数	说明
1	.	点	从左到右	双目
	( )	圆括号	从左到右
	[ ]	方括号	从左到右
2	+	正号	从右到左	单目
	-	负号	从右到左	单目
	++	自增	从右到左	单目	前缀增，后缀增
	- -	自减	从右到左	单目	前缀减，后缀减
	~	按位非/取补运算	从右到左	单目
	！	逻辑非	从右到左	单目	！不与=联用
3	*	乘	从左到右	双目
	/	除	从左到右	双目	整数除法：取商的整数部分，小数部分去掉，不四舍五入
	%	取余	从左到右	双目
4	+	加	从左到右	双目
4	-	减	从左到右	双目
5	<<	左移位运算符	从左到右	双目
	>>	带符号右移位运算符	从左到右	双目
	>>>	无符号右移	从左到右	双目
6	<	小于	从左到右	双目	关系运算符大于说明
	<=	小于或等于	从左到右	双目
	>	大于	从左到右	双目
	>=	大于或等于	从左到右	双目
	instanceof	确定某对象是否属于指定的类	从左到右	双目
7	==	等于	从左到右	双目	关系运算符等于说明
7	!=	不等于	从左到右	双目
8	&	按位与	从左到右	双目
9	\|	按位或	从左到右	双目
10	^	按位异或	从左到右	双目
11	&&	短路与	从左到右	双目
12	\|\|	短路或	从左到右	双目
13	? :	条件运算符	从右到左	三目
14	=	赋值运算符	从右到左	双目
	+=	混合赋值运算符
	-=
	*=
	/=
	%=
	&=
	\|=
	^=
	<<=
	>>=
	>>>=

2.“按位与”运算符和“逻辑”运算符的比较

逻辑运算符是短路运算符，op1&&op2, op1||op2先判断op1，如果op1满足“短路条件(eg.op1&&op2的op1==false;op1||op2的op1==true)”时，就会“短路”，

这时完全不用列会op2的值。

按位与运算符则要先计算op1与op2的值然后再进行判断。

举个例子

public class Operations {
    public static void main(String[] args) {
        int x = 1, y = 0, z = 1;
        boolean isTrue1 = ((y=2) == 1) && ((x=5) == 5);
        System.out.println(x); // 1
        boolean isTrue2 = ((y=2) == 1) & ((z=5) == 5);
        System.out.println(z); // 5
    }
}

3.左移运算
左移运算符<<使指定值的所有位都左移规定的次数。它的通用格式如下所示：
value<<num

这里，num指定要移位值value移动的位数。也就是，左移运算符<<使指定值的所有位都左移num位。每左移一个位，高阶位都被移出（并且丢弃），并用0填充右边。

这意味着当左移的运算数是int类型时，每移动1位它的第31位就要被移出并且丢弃；当左移的运算数是long类型时，每移动1位它的第63位就要被移出并且丢弃。

在对byte和short类型的值进行移位运算时，你必须小心。因为你知道Java在对表达式求值时，将自动把这些类型扩大为int型，而且，表达式的值也是int型。

对byte和short类型的值进行移位运算的结果是int型，而且如果左移不超过31位，原来对应各位的值也不会丢弃。但是，

如果你对一个负的byte或者short类型的值进行移位运算，它被扩大为int型后，它的符号也被扩展。这样，整数值结果的高位就会被1填充。因此，为了得到正确的结果，你就要舍弃得到结果的高位。

这样做的最简单办法是将结果转换为byte型。下面的程序说明了这一点：

public class ByteShift {
    public static void main(String[] args) {
        byte a = 64;
        byte b;
        int i;
        
        i = a << 2;
        b = (byte) (a<<2);
        System.out.println("Original value of a: " + a);
        System.out.println("i: " + i s+ "\nb: " + b);
    }
}

结果：

因变量a在赋值表达式中，故被扩大为int型，64（01000000）被左移两次生成值256（100000000）被赋给变量i。然而，

经过左移后，变量b中惟一的1被移出，低位全部成了0，因此b的值也变成了0。
既然每次左移都可以使原来的操作数翻倍，程序员们经常使用这个办法来进行快速的2的乘法。但是你要小心，

如果你将1移进高阶位（31或63位），那么该值将变为负值。下面的程序说明了这一点：

public class MultByTwo {
    public static void main(String[] args) {
        int i;
        int num = 0xFFFFFFE;
        
        for(i = 0; i < 4; i++) {
            num = num << 1;
            System.out.println(num);
        }
    }
}

结果：

初值经过仔细选择，以便在左移4位后，它会产生-32。正如你看到的，当1被移进31位时，数字被解释为负值。

右移运算符
右移运算符>>使指定值的所有位都右移规定的次数。它的通用格式如下所示：
value>>num
这里，num指定要移位值value移动的位数。也就是，右移运算符>>使指定值的所有位都右移num位。下面的程序片段将值32右移2次，将结果8赋给变量a:
int a=32;
a=a>>2;//a now contains 8
当值中的某些位被“移出”时，这些位的值将丢弃。例如，下面的程序片段将35右移2次，它的2个低位被移出丢弃，也将结果8赋给变量a:
int a=35;
a=a>>2;//astillcontains8
用二进制表示该过程可以更清楚地看到程序的运行过程：
00100011 35
>>2
00001000 8
将值每右移一次，就相当于将该值除以2并且舍弃了余数。你可以利用这个特点将一个整数进行快速的2的除法。当然，你一定要确保你不会将该数原有的任何一位移出。
右移时，被移走的最高位（最左边的位）由原来最高位的数字补充。例如，如果要移走的值为负数，每一次右移都在左边补1，如果要移走的值为正数，每一次右移都在左边补0，这叫做符号位扩展（保留符号位）（signextension），在进行右移操作时用来保持负数的符号。例如，–8>>1是–4，用二进制表示如下：
11111000 –8

>>1

11111100 –4
一个要注意的有趣问题是，由于符号位扩展（保留符号位）每次都会在高位补1，因此-1右移的结果总是–1。有时你不希望在右移时保留符号。

例如，下面的例子将一个byte型的值转换为用十六进制表示。注意右移后的值与0x0f进行按位与运算，这样可以舍弃任何的符号位扩展，以便得到的值可以作为定义数组的下标，

从而得到对应数组元素代表的十六进制字符。

public class HexByte {
	static public void main(String args[]) {

		char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a',
				'b', 'c', 'd', 'e', 'f' };
		byte b = (byte) 0xf1;
		System.out.println("b = 0x" + hex[(b >> 4) & 0x0f] + hex[b & 0x0f]);
	}
}

结果：

4.无符号右移
正如上面刚刚看到的，每一次右移，>>运算符总是自动地用它的先前最高位的内容补它的最高位。这样做保留了原值的符号。但有时这并不是我们想要的。例如，

如果你进行移位操作的运算数不是数字值，你就不希望进行符号位扩展（保留符号位）。当你处理像素值或图形时，这种情况是相当普遍的。在这种情况下，不管运算数的初值是什么，

你希望移位后总是在高位（最左边）补0。这就是人们所说的无符号移动（unsignedshift）。这时你可以使用Java的无符号右移运算符>>>，它总是在左边补0。
下面的程序段说明了无符号右移运算符>>>。在本例中，变量a被赋值为-1，用二进制表示就是32位全是1。这个值然后被无符号右移24位，当然它忽略了符号位扩展，在它的左边总是补0。

这样得到的值255被赋给变量a。
下面用二进制形式进一步说明该操作：
11111111111111111111111111111111int型-1的二进制代码>>>24无符号右移24位00000000000000000000000011111111int型255的二进制代码
由于无符号右移运算符>>>只是对32位和64位的值有意义，所以它并不像你想象的那样有用。因为你要记住，在表达式中过小的值总是被自动扩大为int型。

这意味着符号位扩展和移动总是发生在32位而不是8位或16位。这样，对第7位以0开始的byte型的值进行无符号移动是不可能的，因为在实际移动运算时，

是对扩大后的32位值进行操作。下面的例子说明了这一点：

public class ByteUShfit {
    public static void main(String[] args) {
        int a = 0;
        int b = 2;
        int c = 3;
        
        a |= 4;
        b >>= 1;
        c <<= 1;
        a ^= c;
        
        System.out.println("a = " + a);
        System.out.println("b = " + b);
        System.out.println("c = " + c);
    }
}

结果：