1.运算符的优先级和结合性
序列号 | 符号 | 名称 | 结合性(与操作数) | 目数 | 说明 |
1 | . | 点 | 从左到右 | 双目 | |
( ) | 圆括号 | 从左到右 | | | |
[ ] | 方括号 | 从左到右 | | | |
2 | + | 正号 | 从右到左 | 单目 | |
- | 负号 | 从右到左 | 单目 | | |
++ | 自增 | 从右到左 | 单目 | 前缀增,后缀增 | |
- - | 自减 | 从右到左 | 前缀减,后缀减 | ||
~ | 按位非/取补运算 | 从右到左 | 单目 | | |
! | 逻辑非 | 从右到左 | 单目 | !不与=联用 | |
3 | * | 乘 | 从左到右 | 双目 | |
/ | 除 | 从左到右 | 双目 | 整数除法:取商的整数部分,小数部分去掉,不四舍五入 | |
% | 取余 | 从左到右 | 双目 | | |
4 | + | 加 | 从左到右 | 双目 | |
- | 减 | 从左到右 | 双目 | | |
5 | << | 左移位运算符 | 从左到右 | 双目 | |
>> | 带符号右移位运算符 | 从左到右 | 双目 | | |
>>> | 无符号右移 | 从左到右 | 双目 | | |
6 | < | 小于 | 从左到右 | 双目 | 关系运算符大于说明 |
<= | 小于或等于 | 从左到右 | 双目 | | |
> | 大于 | 从左到右 | 双目 | | |
>= | 大于或等于 | 从左到右 | 双目 | | |
instanceof | 确定某对象是否属于指定的类 | 从左到右 | 双目 | | |
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);
}
}
结果:
5.对于java移位运算的总结:
1.对于左移运算,每左移一个位,高阶位都被移出(并且丢弃),并用0填充右边。这意味着当左移的运算数是int类型时,每移动1位,
它的第31位就要被移出并且丢弃;当左移的运算数是long类型时,每移动1位它的第63位就要被移出并且丢弃。
2.左移都可以使原来的操作数翻倍,程序员们经常使用这个办法来进行快速的2的乘法。但是你要小心,如果你将1移进高阶位(31或63位),
那么该值将变为负值。
3.在对byte和short类型的值进行移位运算时,Java将自动把这些类型扩大为int型,而且,移位后的值也是int型;如果左移不超过31位,
原来对应各位的值不会丢弃。但是,如果你对一个负的byte或者short类型的值进行移位运算,它被扩大为int型后,它的符号也被扩展,结果的高位就会被1填充。
因此,为了得到正确的结果,你就要舍弃得到结果的高位。这样做的最简单办法是将移位运算的结果再转换成byte型。
4.每右移一次,就相当于将该值除以2并且舍弃了余数。你可以利用这个特点将一个整数进行快速的2的除法。当然,你一定要确保你不会将该数原有的任何一位移出。
5.无符号右移(>>>)与右移的区别:
(1)每一次右移,>>运算符总是自动地用它的先前最高位的内容补它的最高位。这样做保留了原值的符号
(2)无符号移动总是在高位(最左边)补0。6.与C、C++不同,Java中没有无符号型整数,而且明确规定了整型和浮点型数据所占的内存字节数,这样就保证了安全性、鲁棒性和平台无关性。
其他:
(1)BCD码(二到十进制编码)人们通常习惯使用十进制数,而计算机内部多采用二进制表示和处理数值数据,因此在计算机输入和输出数据时,
就要进行由十进制到二进制的转换处理。把十进制数的每一位分别写成二进制形式的编码,称为二进制编码的十进制数,
即二到十进制编码或BCD(BinaryCodedDecimal)编码。BCD码编码方法很多,通常采用8421编码,这种编码方法最自然简单。
其方法使用四位二进制数表示一位十进制数,从左到右每一位对应的权分别是23、22、21、20,即8、4、2、1。
例如十进制数1975的8421码可以这样得出1975(D)=0001100101110101(BCD)用四位二进制表示一位十进制会多出6种状态,
这些多余状态码称为BCD码中的非法码。BCD码与二进制之间的转换不是直接进行的,当需要将BCD码转换成二进制码时,要先将BCD码转换成十进制码,
然后再转换成二进制码;当需要将二进制转换成BCD码时,要先将二进制转换成十进制码,然后再转换成BCD码。
(2)字符编码在计算机中,对非数值的文字和其他符号进行处符集的二进制编码就称为ANSI码,DOS和Windows系统都使用了ANSI码。
在输入过程中,系统自动将用户输入的各种数据按编码的类型转换成相应的二进制形式存入计算机存储单元中;在输出过程中,
再由系统自动将二进制编码数据转换成用户可以识别的数据格式输出给用户。
(3)ASCⅡ码用七位二进制表示字符的一种编码,使用一个字节表示一个特殊的字符,字节高位为0或用于在数据传输时的校验。附表为标准的ASCⅡ码表。
参考:http://blog.csdn.net/limenghua9112/article/details/8984662