Java运算符

Java的运算符一般也分为：赋值，算术运算符，逻辑运算符，关系运算符以及等几类，下面是我总结的一些内容： 

赋值

Java中赋值动作是以“=”运算符为之。

基本型别的赋值动作是将某值赋值到另一个值身上。

而对象的赋值是将某一对象的reference复制给另一个reference身上。即将两个reference指向同一个对象。

数学运算符

加（+），减（-），乘（*）

除（/）：在做两个整数除法时，会将所得的结果的小数部分截去，而不会自动四舍五入。

注意：

    当整数类型（byte，short，char，int，long）除以0时，可以编译通过，但是运行时会掷出java.lang.ArithmeticException提示 / by zero

    而当浮点数（float，double）除以0时结果为Infinity(无穷大)；除以-0时结果为-Infinity（负无穷）

模数（%）：只用于整数之间的计算，其结果是两整数相除之后的余数。

注意：

    当整数类型（byte，short，int，char，long）%0时，可以编译通过，但是运行时会掷出java.lang.ArithmeticException提示 %  by zero

   而当浮点数（float，double）% 0时，结果均为：NaN

Java中可以使用这几个数学运算符的简略形式：+=，- =，*=，/=，%=

+和-，还有正、负号的作用，下列语句编译器是可以理解的：

x = a * -b；

等价于：

x = a * （-b）；

不过，我们提倡第二种写法，因为它更清晰、直观。

++：递增运算符；--：递减运算符

关系运算符

Java中的关系运算符有六种：小于（<），小于等于（<=），大于（>），大于等于（>=），等于（= =），不等于（!=）

其中，只有 = = 和!=可以作用于所有基本型别身上，其它四种不可以作用于boolean型别。

特别注意：使用= =和!=比较两个操作数时，两个操作数必须是同一类的数据，这里的分类为：数字（byte,short,int,char,long,float,double）和char；boolean类型；object reference variable共三类，只有同类才可以比较，否则会有编译错误。

关系运算符的结果为boolean（即，结果只能为：true或者false）

对象相等性的测试

关系运算符 = = 和 != 也可以作用于任何对象身上。但是应该注意：他们所比较的只是两个对象引用（object reference）。即，相等或不等只是说两个reference是否指向了同一个object。

而想要知道两个对象的内容是否相等，必须使用equals()函数，任何一个对象都拥有这个函数。

不过应该注意，对于自定义的class，你必须覆写（override）equals()函数，因为equals（）函数的默认行为是比较两个对象的reference。但是，庆幸的是Java标准程序库中的大多数class都覆写了equals()函数，所以它们都会比较对象的内容（而非reference）是否相等。

逻辑运算符

逻辑运算符有3个：&&（AND/与），||（OR/或），！（NOT/非）。

它们的运算结果都是boolean，并且你只能将它们使用于boolean型别的值身上。

此外应该注意，Java中的逻辑表达式的评估是短路式（short-circuiting）的，即，当整个表达式的值可以被确切判断出真伪时，表达式的评估（核定）就会结束，这样，逻辑表达式中的某些部分就可能不会被评估到。

注意：可以充分利用这种短路式的评估特性，写出高效的逻辑表达式（缩短判断的时间）。

位运算符

位运算符有4个：&（按位与，同1为1），|（按位或，同0为0），^（按位异或，同0异1），~（按位取反）。

它们的操作数是整数（实质是对整数的二进制形式进行位操作）

注意：除了~（按位取反）不可以作用于boolean外，其它的四个都可以作用于boolean

      作用于boolean时，其作用规则分别为：

      &：同true为true

      | ：同false为false

      ^ ：同false异true

      且均为非短路操作

移位运算

用来操作基本整型类别的二进制补码形式身上。包括：左移（<<），右移（>>），无符号右移（>>>）。

左移（<<）：连同符号位一起左移，末位补0，（若符号位发生改变则表示溢出）。作用相当于乘以2。

右移（>>）：连同符号位一起右移，符号位不变（0正，1负）

无符号右移（>>>）：整体右移，高位只补0。

位移运算符可以和等号合并使用：<<=，>>=，>>>=都是合法的。

但是将>>=应用于byte和short身上时无法得到正确的结果。这是因为它们会被先晋升为int，然后进行右移；但是当它们被赋值回去时，其值又会被截去（超过容量大小的较高位会被截去）。

注意：如果你的操作数范围小于int（如是byte，short，char）则操作数会被转换成int，在做移位操作，其结果为int

注意：The right-hand side argument of the shift operators is reduced modulo 32 (unless the left-hand side is a long, in which case the right-hand side is reduced modulo 64). For example, the value of 1 << 35 is the same as 1 << 3 or 8.

(一般来说，移位运算符是比较难理解的，因为牵扯到一些计算机低层数据表示的东西。关于移位运算符的更深入的内容在以后的文章中会有详细的说明)

条件运算符

其表达式格式如下： boolean-exp ？ value0 ：value1

表示：如果boolean的结果为true，则整个表达式的值就是value0（可以为表达式）的值，否则整个表达式的值就是value1（可以为表达式）的值。

条件运算符的动作可以使用if-else语句来等价替代，但相比较而言，使用条件运算符更显精炼，而使用等价的if-else语句则表达更清晰，更易阅读。

逗号运算符

这个运算符在Java中只有一种使用方式（也就是说，在Java中只有唯一的一个地方可以使用逗号运算符），那就是在for循环语句中，例如：

for （int i=0, j=1;i<10 && j!=11;i++, j++）{……}

使用+号连接字符串

Java中，+号可以用来连接字符串，如果某个使用+号的表达式，第一个操作数为String，那么持续的所有操作数都必须使String，例如：

Int x = 0，y = 1，z=2；

String sString = “x, y, z”；

System.out.println(sString + x + y + z);

最后一句的显示结果为：x, y, z012

运算符的优先级

应该记住他们的优先级：

运算符类型	运算符
一元的（unary）	+(正)，-（负），++，--
算术运算 和 移位运算 (Arithmetic 以及 shift)	*，/，%，+，-，<<，>>，>>
关系运算符（Relational）	>，<，>=，<=，= =，!=
逻辑运算 和 位运算 （Logic 以及 bitwise）	&&，||，！，~，&，|，^，
条件运算符（conditional）	A > B ? x ：y
赋值运算符以及复合赋值动作	=（以及复合赋值运算符如 *=）

转型运算符

转型运算 也称为 强制类型转换

强制类型转换的形式为：  （要转换的型别名） 被转换的值或者变量；

转型有宽化转换（widening conversion）和窄化转换（narrowing conversion）两种。

进行宽化转换总是安全的，因为新的型别总是有能力容纳来自旧型别的信息，不会遗失任何信息。

进行窄化转换可能会遗失某些信息，但是这是逻辑上的问题，在编译时不会有问题。例如下列代码：

byte x = 2;

int a = 256;

x = (byte) a;

上述语句会编译通过，但是由于byte的最大值为：127，故，x 的最终值被赋于0。（不同的a的值得到的x的值也不同可以编程测试）。

Java可以对于任何的基本型别进行转型，但是boolean是一个唯一的例外。不可以对boolean型别的值/变量做任何转型动作，否则会出现编译错误：“不可转换的类型”。

而对于class型别，只能在（继承体系中）同一族系的对象之间进行转型。否则同样会出现编译错误：“不可转换的类型”。（但是应该注意：在继承体系的兄弟之间也不可以转型）

当你在比int更小的基本型别（亦即char、byte、short）上进行任何数学运算或位运算时，运算之前其值会先被晋升为int，最后所得的结果也会使int型别。

一般来说，表达式内出现的最大数据型别，是决定该表达式运算结果的容量大小的依据之一；如果你让float与double相乘，结果便是double；如果你让int和long相加，结果便是long。

这些转化都是Java自动进行的。

==============补充

：来自网络

移位运算符就是在二进制的基础上对数字进行平移。按照平移的方向和填充数字的规则分为三种：<<（左移）、>>（带符号右移）和>>>（无符号右移）。 
　　在移位运算时，byte、short和char类型移位后的结果会变成int类型，对于byte、short、char和int进行移位时，规定实际移动的次数是移动次数和32的余数，也就是移位33次和移位1次得到的结果相同。移动long型的数值时，规定实际移动的次数是移动次数和64的余数，也就是移动66次和移动2次得到的结果相同。 
　　三种移位运算符的移动规则和使用如下所示： 
　　<<运算规则：按二进制形式把所有的数字向左移动对应的位数，高位移出（舍弃），低位的空位补零。 
　　语法格式： 
　　需要移位的数字 << 移位的次数 
　　例如： 3 << 2，则是将数字3左移2位 
　　计算过程： 
　　3 << 2 
　　首先把3转换为二进制数字0000 0000 0000 0000 0000 0000 0000 0011，然后把该数字高位（左侧）的两个零移出，其他的数字都朝左平移2位，最后在低位（右侧）的两个空位补零。则得到的最终结果是0000 0000 0000 0000 0000 0000 0000 1100，则转换为十进制是12.数学意义： 
　　在数字没有溢出的前提下，对于正数和负数，左移一位都相当于乘以2的1次方，左移n位就相当于乘以2的n次方。 
　　>>运算规则：按二进制形式把所有的数字向右移动对应巍峨位数，低位移出（舍弃），高位的空位补符号位，即正数补零，负数补1. 
　　语法格式： 
　　需要移位的数字 >> 移位的次数 
　　例如11 >> 2，则是将数字11右移2位 
　　计算过程：11的二进制形式为：0000 0000 0000 0000 0000 0000 0000 1011，然后把低位的最后两个数字移出，因为该数字是正数，所以在高位补零。则得到的最终结果是0000 0000 0000 0000 0000 0000 0000 0010.转换为十进制是3.数学意义：右移一位相当于除2，右移n位相当于除以2的n次方。 
　　>>>运算规则：按二进制形式把所有的数字向右移动对应巍峨位数，低位移出（舍弃），高位的空位补零。对于正数来说和带符号右移相同，对于负数来说不同。 
　　其他结构和>>相似。 
　　小结 
　　二进制运算符，包括位运算符和移位运算符，使程序员可以在二进制基础上操作数字，可以更有效的进行运算，并且可以以二进制的形式存储和转换数据，是实现网络协议解析以及加密等算法的基础。 
　　实例操作： 
　　public class URShift { 
　　public static void main(String[] args) { 
　　int i = -1; 
　　i >>>= 10; 
　　//System.out.println(i); 
　　mTest(); 
　　} 
　　public static void mTest(){ 
　　//左移 
　　int i = 12; //二进制为:0000000000000000000000000001100 
　　i <<= 2; //i左移2位，把高位的两位数字(左侧开始)抛弃,低位的空位补0,二进制码就为0000000000000000000000000110000 
　　System.out.println(i); //二进制110000值为48； 
　　System.out.println("<br>"); 
　　//右移 
　　i >>=2; //i右移2为，把低位的两个数字(右侧开始)抛弃,高位整数补0，负数补1，二进制码就为0000000000000000000000000001100 
　　System.out.println(i); //二进制码为1100值为12 
　　System.out.println("<br>"); 
　　//右移example 
　　int j = 11;//二进制码为00000000000000000000000000001011 
　　j >>= 2; //右移两位，抛弃最后两位,整数补0,二进制码为：00000000000000000000000000000010 
　　System.out.println(j); //二进制码为10值为2 
　　System.out.println("<br>"); 
　　byte k = -2; //转为int,二进制码为：0000000000000000000000000000010 
　　k >>= 2; //右移2位，抛弃最后2位，负数补1,二进制吗为：11000000000000000000000000000 
　　System.out.println(j); //二进制吗为11值为2 
　　} 
　　} 
　　在Thinking in Java第三章中的一段话: 
　　移位运算符面向的运算对象也是 
　　二进制的“位”。 可单独用它们处理整数类型（主类型的一种）。左移位运算符（<<）能将运算符左边的运算对象向左移动运算符右侧指定的位数（在低位补0）。 “有符号”右移位运算符（>>）则将运算符左边的运算对象向右移动运算符右侧指定的位数。“有符号”右移位运算符使用了“符号扩展”：若值为正，则在高位插入0；若值为负，则在高位插入1。Java也添加了一种“无符号”右移位运算符（>>>），它使用了“零扩展”：无论正负，都在高位插入0。这一运算符是C或C++没有的。 
　　若对char，byte或者short进行移位处理，那么在移位进行之前，它们会自动转换成一个int。只有右侧的5个低位才会用到。这样可防止我们在一个int数里移动不切实际的位数。若对一个long值进行处理，最后得到的结果也 是long。此时只会用到右侧的6个低位，防止移动超过long值里现成的位数。但在进行“无符号”右移位时，也可能遇到一个问题。若对byte或 short值进行右移位运算，得到的可能不是正确的结果（Java 1.0和Java 1.1特别突出）。它们会自动转换成int类型，并进行右移位。但“零扩展”不会发生，所以在那些情况下会得到-1的结果。   



----------- 






Java 定义的位运算（bitwise operators ）直接对整数类型的位进行操作，这些整数类型包括long，int，short，char，and byte 。表4-2 列出了位运算： 
表4.2 位运算符及其结果 

运算符 结果 
~ 按位非（NOT）（一元运算） 
& 按位与（AND） 
| 按位或（OR） 
^ 按位异或（XOR） 
>> 右移 
>>> 右移，左边空出的位以0填充 
运算符 结果 
<< 左移 
&= 按位与赋值 
|= 按位或赋值 
^= 按位异或赋值 
>>= 右移赋值 
>>>= 右移赋值，左边空出的位以0填充 
<<= 左移赋值 

续表 

既然位运算符在整数范围内对位操作，因此理解这样的操作会对一个值产生什么效果是重要的。具体地说，知道Java 是如何存储整数值并且如何表示负数的是有用的。因此，在继续讨论之前，让我们简短概述一下这两个话题。 

所有的整数类型以二进制数字位的变化及其宽度来表示。例如，byte 型值42的二进制代码是00101010 ，其中每个位置在此代表2的次方，在最右边的位以20开始。向左下一个位置将是21，或2，依次向左是22，或4，然后是8，16，32等等，依此类推。因此42在其位置1，3，5的值为1（从右边以0开始数）；这样42是21+23+25的和，也即是2+8+32 。 

所有的整数类型（除了char 类型之外）都是有符号的整数。这意味着他们既能表示正数，又能表示负数。Java 使用大家知道的2的补码（two’s complement ）这种编码来表示负数，也就是通过将与其对应的正数的二进制代码取反（即将1变成0，将0变成1），然后对其结果加1。例如，-42就是通过将42的二进制代码的各个位取反，即对00101010 取反得到11010101 ，然后再加1，得到11010110 ，即-42 。要对一个负数解码，首先对其所有的位取反，然后加1。例如-42，或11010110 取反后为00101001 ，或41，然后加1，这样就得到了42。 

如果考虑到零的交叉（zero crossing ）问题，你就容易理解Java （以及其他绝大多数语言）这样用2的补码的原因。假定byte 类型的值零用00000000 代表。它的补码是仅仅将它的每一位取反，即生成11111111 ，它代表负零。但问题是负零在整数数学中是无效的。为了解决负零的问题，在使用2的补码代表负数的值时，对其值加1。即负零11111111 加1后为100000000 。但这样使1位太靠左而不适合返回到byte 类型的值，因此人们规定，-0和0的表示方法一样，-1的解码为11111111 。尽管我们在这个例子使用了byte 类型的值，但同样的基本的原则也适用于所有Java 的整数类型。 

因为Java 使用2的补码来存储负数，并且因为Java 中的所有整数都是有符号的，这样应用位运算符可以容易地达到意想不到的结果。例如，不管你如何打算，Java 用高位来代表负数。为避免这个讨厌的意外，请记住不管高位的顺序如何，它决定一个整数的符号。 

4.2.1 位逻辑运算符 
位逻辑运算符有“与”（AND）、“或”（OR）、“异或（XOR ）”、“非（NOT）”，分别用“&”、“|”、“^”、“~”表示，4-3 表显示了每个位逻辑运算的结果。在继续讨论之前，请记住位运算符应用于每个运算数内的每个单独的位。 
表4-3 位逻辑运算符的结果 
A 0 1 0 1 B 0 0 1 1 A | B 0 1 1 1 A & B 0 0 0 1 A ^ B 0 1 1 0 ~A 1 0 1 0 

按位非（NOT） 

按位非也叫做补，一元运算符NOT“~”是对其运算数的每一位取反。例如，数字42，它的二进制代码为： 

00101010 

经过按位非运算成为 

11010101 

按位与（AND） 

按位与运算符“&”，如果两个运算数都是1，则结果为1。其他情况下，结果均为零。看下面的例子： 

00101010 42 &00001111 15 

00001010 10 

按位或（OR） 

按位或运算符“|”，任何一个运算数为1，则结果为1。如下面的例子所示： 

00101010 42 | 00001111 15 

00101111 47 

按位异或（XOR） 

按位异或运算符“^”，只有在两个比较的位不同时其结果是 1。否则，结果是零。下面的例子显示了“^”运算符的效果。这个例子也表明了XOR 运算符的一个有用的属性。注意第二个运算数有数字1的位，42对应二进制代码的对应位是如何被转换的。第二个运算数有数字0的位，第一个运算数对应位的数字不变。当对某些类型进行位运算时，你将会看到这个属性的用处。 

00101010 42 ^ 00001111 15 

00100101 37 
位逻辑运算符的应用 

下面的例子说明了位逻辑运算符： 

// Demonstrate the bitwise logical operators. 
class BitLogic { 
public static void main(String args[]) { 


String binary[] = {"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111", "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111" 

}; 
int a = 3; // 0 + 2 + 1 or 0011 in binary 
int b = 6; // 4 + 2 + 0 or 0110 in binary 
int c = a | b; 
int d = a & b; 
int e = a ^ b; 
int f = (~a & b) | (a & ~b); 
int g = ~a & 0x0f; 


System.out.println(" a = " + binary[a]); 
System.out.println(" b = " + binary[b]); 
System.out.println(" a|b = " + binary[c]); 
System.out.println(" a&b = " + binary[d]); 
System.out.println(" a^b = " + binary[e]); 
System.out.println("~a&b|a&~b = " + binary[f]); 
System.out.println(" ~a = " + binary[g]); 


} 
} 


在本例中，变量a与b对应位的组合代表了二进制数所有的 4 种组合模式：0-0，0-1，1-0 ，和1-1 。“|”运算符和“&”运算符分别对变量a与b各个对应位的运算得到了变量c和变量d的值。对变量e和f的赋值说明了“^”运算符的功能。字符串数组binary 代表了0到15 对应的二进制的值。在本例中，数组各元素的排列顺序显示了变量对应值的二进制代码。数组之所以这样构造是因为变量的值n对应的二进制代码可以被正确的存储在数组对应元素binary[n] 中。例如变量a的值为3，则它的二进制代码对应地存储在数组元素binary[3] 中。~a的值与数字0x0f （对应二进制为0000 1111 ）进行按位与运算的目的是减小~a的值，保证变量g的结果小于16。因此该程序的运行结果可以用数组binary 对应的元素来表示。该程序的输出如下： 

a = 0011 b = 0110 a|b = 0111 a&b = 0010 a^b = 0101 ~a&b|a&~b = 0101 ~a = 1100 

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

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 型。下面的程序说明了这一点： 

// Left shifting a byte value. 
class ByteShift { 


public static void main(String args[]) { 
byte a = 64, b; 
int i; 


i = a << 2; 
b = (byte) (a << 2); 


System.out.println("Original value of a: " + a); 
System.out.println("i and b: " + i + " " + b); 
} 
} 


该程序产生的输出下所示： 

Original value of a: 64 
i and b: 256 0 


因变量a在赋值表达式中，故被扩大为int 型，64（0100 0000 ）被左移两次生成值256 （10000 0000 ）被赋给变量i。然而，经过左移后，变量b中惟一的1被移出，低位全部成了0，因此b的值也变成了0。 

既然每次左移都可以使原来的操作数翻倍，程序员们经常使用这个办法来进行快速的2 的乘法。但是你要小心，如果你将1移进高阶位（31或63位），那么该值将变为负值。下面的程序说明了这一点： 

// Left shifting as a quick way to multiply by 2. 
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); 


} 
} 
这里，num 指定要移位值value 移动的位数。也就是，左移运算符<<使指定值的所有位都左移num位。每左移一个位，高阶位都被移出（并且丢弃），并用0填充右边。这意味着当左移的运算数是int 类型时，每移动1位它的第31位就要被移出并且丢弃；当左移的运算数是long 类型时，每移动1位它的第63位就要被移出并且丢弃。 

在对byte 和short类型的值进行移位运算时，你必须小心。因为你知道Java 在对表达式求值时，将自动把这些类型扩大为 int 型，而且，表达式的值也是int 型。对byte 和short类型的值进行移位运算的结果是int 型，而且如果左移不超过31位，原来对应各位的值也不会丢弃。但是，如果你对一个负的byte 或者short类型的值进行移位运算，它被扩大为int 型后，它的符号也被扩展。这样，整数值结果的高位就会被1填充。因此，为了得到正确的结果，你就要舍弃得到结果的高位。这样做的最简单办法是将结果转换为byte 型。下面的程序说明了这一点： 

// Left shifting a byte value. 
class ByteShift { 


public static void main(String args[]) { 
byte a = 64, b; 
int i; 


i = a << 2; 
b = (byte) (a << 2); 


System.out.println("Original value of a: " + a); 
System.out.println("i and b: " + i + " " + b); 
} 
} 


该程序产生的输出下所示： 

Original value of a: 64 
i and b: 256 0 


因变量a在赋值表达式中，故被扩大为int 型，64（0100 0000 ）被左移两次生成值256 （10000 0000 ）被赋给变量i。然而，经过左移后，变量b中惟一的1被移出，低位全部成了0，因此b的值也变成了0。 

既然每次左移都可以使原来的操作数翻倍，程序员们经常使用这个办法来进行快速的2 的乘法。但是你要小心，如果你将1移进高阶位（31或63位），那么该值将变为负值。下面的程序说明了这一点： 

// Left shifting as a quick way to multiply by 2. 
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); 


} 
} 
} 

该程序的输出如下所示： 

536870908 
1073741816 
2147483632 
-32 


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

4.2.3 右移运算符 
右移运算符>>使指定值的所有位都右移规定的次数。它的通用格式如下所示： 

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; // a still contains 8 


用二进制表示该过程可以更清楚地看到程序的运行过程： 

00100011 35 
>> 2 
00001000 8 


将值每右移一次，就相当于将该值除以2并且舍弃了余数。你可以利用这个特点将一个整数进行快速的2的除法。当然，你一定要确保你不会将该数原有的任何一位移出。 

右移时，被移走的最高位（最左边的位）由原来最高位的数字补充。例如，如果要移走的值为负数，每一次右移都在左边补1，如果要移走的值为正数，每一次右移都在左边补0，这叫做符号位扩展（保留符号位）（sign extension ），在进行右移操作时用来保持负数的符号。例如，–8 >> 1 是–4，用二进制表示如下： 

11111000 –8 >>1 11111100 –4 

一个要注意的有趣问题是，由于符号位扩展（保留符号位）每次都会在高位补1，因此-1右移的结果总是–1。有时你不希望在右移时保留符号。例如，下面的例子将一个byte 型的值转换为用十六 
进制表示。注意右移后的值与0x0f进行按位与运算，这样可以舍弃任何的符号位扩展，以便得到的值可以作为定义数组的下标，从而得到对应数组元素代表的十六进制字符。 

// Masking sign extension. 
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]);}} 

该程序的输出如下： 

b = 0xf1 

4.2.4 无符号右移 
正如上面刚刚看到的，每一次右移，>>运算符总是自动地用它的先前最高位的内容补它的最高位。这样做保留了原值的符号。但有时这并不是我们想要的。例如，如果你进行移位操作的运算数不是数字值，你就不希望进行符号位扩展（保留符号位）。当你处理像素值或图形时，这种情况是相当普遍的。在这种情况下，不管运算数的初值是什么，你希望移位后总是在高位（最左边）补0。这就是人们所说的无符号移动（unsigned shift ）。这时你可以使用Java 的无符号右移运算符>>> ，它总是在左边补0。 

下面的程序段说明了无符号右移运算符>>> 。在本例中，变量a被赋值为-1，用二进制表示就是32位全是1。这个值然后被无符号右移24位，当然它忽略了符号位扩展，在它的左边总是补0。这样得到的值255被赋给变量a。 

int a = -1; a = a >>> 24; 

下面用二进制形式进一步说明该操作： 

11111111 11111111 11111111 11111111 int型-1的二进制代码>>> 24 无符号右移24位00000000 00000000 00000000 11111111 int型255的二进制代码 

由于无符号右移运算符>>> 只是对32位和64位的值有意义，所以它并不像你想象的那样有用。因为你要记住，在表达式中过小的值总是被自动扩大为int 型。这意味着符号位扩展和移动总是发生在32位而不是8位或16位。这样，对第7位以0开始的byte 型的值进行无符号移动是不可能的，因为在实际移动运算时，是对扩大后的32位值进行操作。下面的例子说明了这一点： 

// Unsigned shifting a byte value. 
class ByteUShift { 
static public void main(String args[]) { 
进制表示。注意右移后的值与0x0f进行按位与运算，这样可以舍弃任何的符号位扩展，以便得到的值可以作为定义数组的下标，从而得到对应数组元素代表的十六进制字符。 
// Masking sign extension. 
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]);}} 

该程序的输出如下： 

b = 0xf1 

4.2.4 无符号右移 
正如上面刚刚看到的，每一次右移，>>运算符总是自动地用它的先前最高位的内容补它的最高位。这样做保留了原值的符号。但有时这并不是我们想要的。例如，如果你进行移位操作的运算数不是数字值，你就不希望进行符号位扩展（保留符号位）。当你处理像素值或图形时，这种情况是相当普遍的。在这种情况下，不管运算数的初值是什么，你希望移位后总是在高位（最左边）补0。这就是人们所说的无符号移动（unsigned shift ）。这时你可以使用Java 的无符号右移运算符>>> ，它总是在左边补0。 

下面的程序段说明了无符号右移运算符>>> 。在本例中，变量a被赋值为-1，用二进制表示就是32位全是1。这个值然后被无符号右移24位，当然它忽略了符号位扩展，在它的左边总是补0。这样得到的值255被赋给变量a。 

int a = -1; a = a >>> 24; 

下面用二进制形式进一步说明该操作： 

11111111 11111111 11111111 11111111 int型-1的二进制代码>>> 24 无符号右移24位00000000 00000000 00000000 11111111 int型255的二进制代码 

由于无符号右移运算符>>> 只是对32位和64位的值有意义，所以它并不像你想象的那样有用。因为你要记住，在表达式中过小的值总是被自动扩大为int 型。这意味着符号位扩展和移动总是发生在32位而不是8位或16位。这样，对第7位以0开始的byte 型的值进行无符号移动是不可能的，因为在实际移动运算时，是对扩大后的32位值进行操作。下面的例子说明了这一点： 
// Unsigned shifting a byte value. 
class ByteUShift { 
static public void main(String args[]) { 
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); 
} 
} 

该程序的输出如下所示： 

a = 3 
b = 1 
c = 6 

--------------------------------------------- 

http://blog.csdn.net/xuchenguang/article/details/2301550 

Java的移位操作(收集+纠正+排版) 

此收集来源于网络收集，是我整理、纠正以及排版，来为大家提供全面一点的知识讲解，可能有些地方排的不好，望谅解。 
====================================================================================== 
JAVA中位运算符包括: 
& 
| 
~ 
^ 
<< 
>> 
>>> 

一、 
首先要搞清楚参与运算的数的位数： 
( 
联想：java的8种基本类型：byte,short, char, int, long,float,double,boolean. 
   在内存中固定长度(字节)：1      2       2       4     8     4       8      true/false 
   这些固定类型的长度与具体的软硬件环境无关。这一点与C++不同,Java中的char类型用Unicode码储存 

与此对应的，java提供了8种包装类型： 
Byte,Short,Character,Integer,Long,Float,Double,Boolean. 
它们之间的相互转换：例如： 
double a=1; 
//把double基本类型转换为Double包装类型 
Double b=new Double(a); 
//把Double包装类型转换为double基本类型 
a=b.doubleValue(); 
) 

所以int的是32位。long的是64位。 

如int i = 1; 
i的二进制原码表示为： 
00000000000000000000000000000001 

long l = 1; 
l的二进制原码表示为： 
0000000000000000000000000000000000000000000000000000000000000001 

二、 
原码——符号位为0表示正数，为1表示负数； 
其余各位等同于真值的绝对值。 
如：0000000000000010B=2，1000000000000010B=-2 
反码——符号位的用法及正数的表示与“原码”一样； 
负数的表示是在“原码”表示的基础上通过将符号位以外 
的各位取反来获得的。 
如：0000000000000010B=2，1111111111111101B=-2 
补码——符号位的用法及正数的表示与“原码”一样； 
负数的表示是在“反码”的基础上通过加1来获得的。 
如：00000010B=2，11111110B=-2 

如int i = -1; 
10000000000000000000000000000001,最高位是符号位。正数为0，负数为1。 
符号位不变，其他位逐位取反后： 
11111111111111111111111111111110,即反码。 
反码加1： 
11111111111111111111111111111111,即补码。 
================================================================== 
   注意：负数都是用补码参与运算的。得到的也是补码，需要减1取反获得原码。          
           千万要理解这句话!!!                                                                                                     
================================================================== 

三、 
常用的位运算符0在位运算中是比较特殊的。 
　 
& 与。    全1为1， 有0为0。　　任何数与0与都等于0。　　 
| 或。      有1为1， 全0为0。　　任何数与0或都等于原值。 
~ 非。     逐位取反 
^ 异或。  相同为0，相异为1。      任何数与0异或都等于原值。 

对于int类型数据来说： 
1.<< 
逻辑左移,右边补0,符号位就是被移动到的位. 
正数: 
x<<1一般相当于2x,但是可能溢出. 
若x在这个范围中: 2的30次方~(2的31次方-1) 二进制表示 0100...0000到0111...1111,<<后最高为变为1了,变成负数了. 
负数: 
x<<1一般也相当于2x,也有可能溢出. 
若x在这个范围中: -2的31次方~-(2的30次方+1)二进制表示1000...0000到1011...1111,<<后最高为变成0了,变成正数了. 

2.>> 
算术右移,和上面的不对应,为正数时左边补0,为负数时左边补1. 
x>>1,相当于x/2,余数被舍弃,因为这个是缩小,所以不会溢出. 
不过有一点要注意: -1右移多少位都是-1.(这个道理很简单嘛，呵呵) 
另外舍弃的余数是正的: 
3>>1=1  舍弃的余数是1. 
-3>>1=-2 舍弃的余数也是1,而不是-1. 
对于正数 x>>1和x/2相等 
对于负数 x>>1和x/2不一定相等. 

3.>>> 
逻辑右移,这个才是和<<对应的 
这个把符号位一起移动,左边补0 
对于正数,>>>和>>是一样的 
对于负数,右移之后就变成正数了. 

可以使用Integer.toBinaryString(int i)来看01比特,更加直观. 

四、 
负数参与的运算，得到的是补码，负数得到原码的方法： 
　　方法一：将补码先减1，再逐位取反，得到原码。即为运算结果。 
　　方法二：将补码先逐位取反，再加1，得到原码。即为运算结果。 
0例外，如果得到的是0，则不需这两种方法，即得到的原码位0。 
另外，两个正数运算后得到的就是原码,不需要再用求原码方法。 


举例： 
-1＾1, 
-1 
10000000000000000000000000000001--原码 
11111111111111111111111111111110--反码 
11111111111111111111111111111111--补码 
1 
00000000000000000000000000000001--原码 

则-1^1等于 
11111111111111111111111111111111^ 
00000000000000000000000000000001= 
11111111111111111111111111111110--补码 
11111111111111111111111111111101--反码 
10000000000000000000000000000010--原码==-2 
即-1^1=-2 

举例： 
-2^1 
-2 
10000000000000000000000000000010--原码 
11111111111111111111111111111101--反码 
11111111111111111111111111111110--补码 
1 
00000000000000000000000000000001--原码 
则-2^-1等于 
11111111111111111111111111111110^ 
00000000000000000000000000000001= 
11111111111111111111111111111111--补码 
11111111111111111111111111111110--反码 
10000000000000000000000000000001--原码==-1 

下面的是cooltigerzsh(阿波罗) 于 2005-2-4 15:16:07对(<<、>>、 >>>)的一翻讲解： 

移位运算符面向的运算对象也是二进制的“位”。可单独用它们处理整数类型（主类型的一种）。 
左移位运算符（<<）能将运算符左边的运算对象向左移动运算符右侧指定的位数（在低位补0）。 
“有符号”右移位运算符（>>）则将运算符左边的运算对象向右移动运算符右侧指定的位数。 
“有符号”右移位运算符使用了“符号扩展”：若值为正，则在高位插入0；若值为负，则在高位插入1。 
Java也添加了一种“无符号”右移位运算符（>>>），它使用了“零扩展”：无论正负，都在高位插入0。 
这一运算符是C或C 没有的。若对char，byte或者short进行移位处理，那么在移位进行之前，它们会自动转换成一个int。 
只有右侧的5个低位才会用到。这样可防止我们在一个int数里移动不切实际的位数。 
若对一个long值进行处理，最后得到的结果也是long。此时只会用到右侧的6个低位，防止移动超过long值里现成的位数。 
但在进行“无符号”右移位时，也可能遇到一个问题。若对byte或short值进行右移位运算， 
得到的可能不是正确的结果（Java 1.0和Java 1.1特别突出）。它们会自动转换成int类型，并进行右移位。 
但“零扩展”不会发生，所以在那些情况下会得到-1的结果。 

如： 
public class URShift { 
public static void main(String[] args) { 
int i = -1; 
i >>>= 10; 
System.out.println(i); 
long l = -1; 
l >>>= 10; 
System.out.println(l); 
short s = -1; 
s >>>= 10; 
System.out.println(s); 
byte b = -1; 
b >>>= 10; 
System.out.println(b); 
} 
} 
输出结果： 
4194303 
18014398509481983 
-1 
-1 

=============================================================================== 
还有一点不得不提，也是非常隐含的一点，那就是我在Einstein的BLOG上找到的，他说是SCJP上的题， 
摘录他的文章如下： 

SCJP里的题还真是"噶"呀,很多都是让人想不到的问题,有点意思.哈哈,今天最后一个,之后趴趴,太晚了, 
明天还是去沈阳卖数码相机呢(兴奋ing...) 

下面代码: 
class test002 
{ 
public static void main(String[] agrs) 
{ 
  int i=-1; 
  int j=i>>>32; 
  System.out.println(j); 
} 
} 
按照我的理解应该输出:0,因为JAVA的INT类型是占4字节的,也就是说占32位,当右移了32位的时候所有的位应该都变成0,但输出结果确是:-1, 
想了很久没想明白就上网发了个帖子问了一下,非常感谢coffer283和danieljill()两位朋友. 
原来在JAVA进行移位运算中因为int是占32位,进行移位的数是32的模,所以当i>>>32的时候就等于i>>>0,相当于没有进行移位. 
我又试了试long类型的移位,long占8字节也就是64位,所以移位的数是64的模. 
--------------------------------------------------------------------------------------------------- 

上面是他的问题，给了我不少的启发，对Java的移位运算有了跟深一层的理解。 
同时我也对byte,short类型的移位周期做了实验，也是32，跟int类型的相同，从而也验证了byte、short进行右移位运算，会自动转换成int类型，我并验证了<<、>>、>>>这3个移位运算符都遵循移位周期。