Java中的二进制及基本的位运算

二进制是计算技术中广泛采用的一种数制。二进制数据是用0和1两个数码来表示的数。它的基数为2，进位规则是“逢二进一”，借位规则是“借一当二”，由18世纪德国数理哲学大师莱布尼兹发现。当前的计算机系统使用的基本上是二进制系统，数据在计算机中主要是以补码的形式存储的。计算机中的二进制则是一个非常微小的开关，用“开”来表示1，“关”来表示0。

那么Java中的二进制又是怎么样的呢？让我们一起来揭开它神秘的面纱吧。

一、Java内置的进制转换

有关十进制转为二进制，和二进制转为十进制这种基本的运算方法这里就不展开讲了。

在Java中内置了几个方法来帮助我们进行各种进制的转换。如下图所示(以Integer整形为例，其他类型雷同)：

1，十进制转化为其他进制：1 二进制：Integer.toHexString(int i);

2 八进制：Integer.toOctalString(int i);

3 十六进制：Integer.toBinaryString(int i);

2,其他进制转化为十进制：1 二进制：Integer.valueOf("0101",2).toString;

2 八进制：Integer.valueOf("376",8).toString;

3 十六进制：Integer.valueOf("FFFF",16).toString;

3,使用Integer类中的parseInt()方法和valueOf()方法都可以将其他进制转化为10进制。

不同的是parseInt()方法的返回值是int类型，而valueOf()返回值是Integer对象。

二、基本的位运算

二进制可以和十进制一样加减乘除，但是它还有更简便的运算方式就是——位运算。比如在计算机中int类型的大小是32bit，可以用32位的二进制数来表示，所以我们可以用位运算来对int类型的数值进行计算，当然你也可以用平常的方法来计算一些数据，这里我主要为大家介绍位运算的方法。我们会发现位运算有着普通运算方法不可比拟的力量。更多位运算应用请转移到我下篇博文《神奇的位运算》

首先，看一下位运算的基本操作符：

优点：

特定情况下，计算方便，速度快，被支持面广

如果用算数方法，速度慢，逻辑复杂

位运算不限于一种语言，它是计算机的基本运算方法

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

(一)按位与&

两位全为1，结果才为1

0&0=0；0&1=0；1&0=0；1&1=1

例如：51&5 即0011 0011 & 0000 0101 =0000 0001 因此51&5=1.

特殊用法

(1)清零。如果想将一个单元清零，即使其全部二进制位为0，只要与一个各位都是零的数值相与，结果为零。

(2)取一个数中指定位。

例如：设X=10101110，取X的低四位，用X&0000 1111=0000 1110即可得到。

方法：找一个数，对应x要取的位，该数的对应位为1，其余位为零，此数与x进行“与运算”可以得到x中的指定位。

(二)按位或 |

只要有一个为1，结果就为1。

0|0=0； 0|1=1；1|0=1；1|1=1；

例如：51|5 即0011 0011 | 0000 0101 =0011 0111 因此51|5=55

特殊用法

常用来对一个数据的某些位置1。

方法：找到一个数，对应x要置1的位，该数的对应位为1，其余位为零。此数与x相或可使x中的某些位置1。

(三)异或 ^

两个相应位为“异”(值不同)，则该位结果为1，否则为0

0^0=0; 0^1=1; 1^0=1; 1^1=0;

例如：51^5 即0011 0011 ^ 0000 0101 =0011 0110 因此51^5=54

特殊用法

(1) 与1相异或，使特定位翻转

方法：找一个数，对应X要翻转的位，该数的对应为1，其余位为零，此数与X对应位异或即可。

例如：X=1010 1110，使X低四位翻转，用X^0000 1111=1010 0001即可得到。

(2) 与0相异或，保留原值

例如：X^0000 0000 =1010 1110

(3)两个变量交换值

1.借助第三个变量来实现

C=A;A=B;B=C;

2.利用加减法实现两个变量的交换

A=A+B;B=A-B;A=A-B;

3.用位异或运算来实现，也是效率最高的

原理：一个数异或本身等于0 ；异或运算符合交换律

A=A^B;B=A^B;A=A^B

(四)取反与运算~

对一个二进制数按位取反，即将0变为1，1变0

~1=0 ；~0=1

(五)左移<<

将一个运算对象的各二进制位全部左移若干位(左边的二进制位丢弃，右边补0)

例如： 2<<1 =4 10<<1=100

若左移时舍弃的高位不包含1，则每左移一位，相当于该数乘以2。

例如：11(1011)<<2= 0010 1100=22

11(00000000 00000000 00000000 1011)整形32bit

(六)右移>>

将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。若右移时舍高位不是1(即不是负数)，操作数每右移一位，相当于该数除以2。

左补0还是补1得看被移数是正还是负。

例如：4>>2=4/2/2=1

-14(即1111 0010)>>2 =1111 1100=-4

(七)无符号右移运算>>>

各个位向右移指定的位数，右移后左边空出的位用零来填充，移除右边的位被丢弃。

例如：-14>>>2

(即11111111 11111111 11111111 11110010)>>>2

=(00111111 11111111 11111111 11111100)=1073741820

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

上述提到的负数，他的二进制位表示和正数略有不同，所以在位运算的时候也与正数不同。

负数以其正数的补码形式表示！

以上述的-14为例，来简单阐述一下原码、反码和补码。

原 码

一个整数按照绝对值大小转化成的二进制数称为原码

例如：00000000 00000000 00000000 00001110 是14的原码。

反 码

将二进制数按位取反，所得到的新二进制数称为原二进制数的反码。

例如：将00000000 00000000 00000000 00001110 每一位取反，

得11111111 11111111 11111111 11110001

注意：这两者互为反码

补 码

反码加1称为补码11111111 11111111 11111111 11110001 +1=

11111111 11111111 11111111 11110010

现在我们得到-14的二进制表示，现在将它左移-14(11111111 11111111 11111111 11110010)<<2 =

11111111 11111111 11111111 11001000

=？

分析：这个二进制的首位为1，说明是补码形式，现在我们要将补码转换为原码(它的正值)

跟原码转换为补码相反，将补码转换为原码的步骤：

补码减1得到反码：(11000111)前24位为1，此处省略

反码取反得到原码(即该负数的正值)(00111000)

计算正值，正值为56

取正值的相反数，得到结果-56

结论：-14<<2 = -56

三、Java中进制运算

Java中二进制用的多吗？

平时开发中“进制转换”和“位操作”用的不多，Java处理的是高层。

在跨平台中用的较多，如：文件读写，数据通信。

来看一个场景：

如果客户机和服务器都是用Java语言写的程序，那么当客户机发送对象数据，我们就可以把要发送的数据序列化serializable，服务器端得到序列化的数据之后就可以反序列化，读出里面的对象数据。

随着客户机访问量的增大，我们不考虑服务器的性能，其实一个可行的方案就是把服务器的Java语言改成C语言。

C语言作为底层语言，反映速度都比Java语言要快，而此时如果客户端传递的还是序列化的数据，那么服务器端的C语言将无法解析，怎么办呢？我们可以把数据转为二进制(0，1)，这样的话服务器就可以解析这些语言。

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Java中基本数据类型有以下四种：

Int数据类型：byte(8bit，-128~127)、short(16bit)、int(32bit)、long(64bit)

float数据类型：单精度(float，32bit ) 、双精度(double,64bit)

boolean类型变量的取值有true、false(都是1bit)

char数据类型：unicode字符，16bit

对应的类类型：

Integer、Float、Boolean、Character、Double、Short、Byte、Long

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

(一)数据类型转为字节

例如：int型8143(00000000 00000000 00011111 11001111)

=>byte[] b=[-49,31,0,0]

第一个(低端)字节：8143>>0*8 & 0xff=(11001111)=207(或有符号-49)

第二个(低端)字节：8143>>1*8 &0xff=(00011111)=31

第三个(低端)字节：8143>>2*8 &0xff=00000000=0

第四个(低端)字节：8143>>3*8 &0xff=00000000=0

我们注意到上面的(低端)是从右往左开始的，那什么是低端呢？我们从大小端的角度来说明。

小端法(Little-Endian)

低位字节排放在内存的低地址端即该值的起始地址，高位字节排位在内存的高地址端

大端法(Big-Endian)

高位字节排放在内存的低地址端即该值的起始地址，低位字节排位在内存的高地址端

为什么会有大小端模式之分呢？

这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节，一个字节为8bit。但是在C语言中除了8bit的char之外，还有16bit的short型，32bit的long型(要看具体的编译器)，另外，对于位数大于8位的处理器，例如16位或者32位的处理器，由于寄存器宽度大于一个字节，那么必然存在着一个如果将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。例如一个16bit的short型x，在内存中的地址为0x0010，x的值为0x1122，那么0x11为高字节，0x22为低字节。对于大端模式，就将0x11放在低地址中，即0x0010中，0x22放在高地址中，即0x0011中。小端模式，刚好相反。我们常用的X86结构是小端模式，而KEIL C51则为大端模式。很多的ARM，DSP都为小端模式。有些ARM处理器还可以由硬件来选择是大端模式还是小端模式。

例如：32bit的数0x12 34 56 78(十二进制)

在Big-Endian模式CPU的存放方式(假设从地址0x4000开始存放)为

内存地址

0x4000

0x4001

0x4002

0x4003

存放内容

0x78

0x56

0x34

0x12

在Little-Endian模式CPU的存放方式(假设从地址0x4000开始存放)为

内存地址

0x4000

0x4001

0x4002

0x4003

存放内容

0x12

0x34

0x56

0x78

(二)字符串转化为字节

1.字符串->字节数组1 String s;

2 byte[] bs=s.getBytes();

2.字节数组->字符串1 Byte[] bs=new byte[int];

2 String s =new String(bs);或

3 String s=new String(bs,encode);//encode指编码方式，如utf-8

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

两种类型转化为字节的方法都介绍了，下面写个小例子检验一下：public class BtyeTest {

/*

* int整型转为byte字节

*/

public static byte[] intTOBtyes(int in){

byte[] arr=new byte[4];

for(int i=0;i<4;i++){

arr[i]=(byte)((in>>8*i) & 0xff);

}

return arr;

}

/*

* byte字节转为int整型

*/

public static int bytesToInt(byte[] arr){

int sum=0;

for(int i=0;i

sum+=(int)(arr[i]&0xff)<<8*i;

}

return sum;

}

public static void main(String[] args) {

// TODO Auto-generated method stub

byte[] arr=intTOBtyes(8143);

for(byte b:arr){

System.out.print(b+" ");

}

System.out.println();

System.out.println(bytesToInt(arr));

//字符串与字节数组

String str="云开的立夏de博客园";

byte[] barr=str.getBytes();

String str2=new String(barr);

System.out.println("字符串转为字节数组：");

for(byte b:barr){

System.out.print(b+" ");

}

System.out.println();

System.out.println("字节数组换位字符串："+str2);

}

}

转载http://blog.csdn.net/u012713968/article/details/50481680

一，位运算基础
位运算（包括与，或，取反，异或，左移，右移等）是程序设计中的一个重要的领域。尤其是安全和底层开发中，除了指针的频繁使用之外，位运算是另一个非常频繁使用的领域。 因此，在求职面试中，位运算也是每年重点考查的知识点。首先，我们有必要复习一下C语言中位运算的一些基础计算方法。
 

1，与运算：&

与运算的操作符为&。2个数进行与运算时，就是将这2个数的二进制进行与操作， 只有当2个数对应的位都为1，该位运算结果为1，否则运算结果为0。即：1&1=1；1&0=0；0&0=0. 比如计算15&10，首先15的二进制为：1111，10的二进制为1010(二进制，十进制和十六进制转化方法： 点击这里 )，所以15&10为： 所以15&10=10。 

2，或运算：|

或运算的操作符为|。2个数进行或运算时，就是将这2个数的二进制进行或操作， 只要2个数对应的位有一个为1，该位运算结果为1，否则运算结果为0。即：1|1=1;1|0=1;0|0=0. 比如计算15&10，首先15的二进制为：1111，10的二进制为1010，所以15|10为： 所以15|10=15。 

3，取反运算：~

取反运算的操作符为~，为单目运算符。取反运算符顾名思义，就是将一个整数中位为1的变成0，位为0的变成1。即：~1=0;~0=1. 比如计算~10，首先10的二进制为：1010，~10为： ~10=5。

 

4，异或运算：^

异或运算的操作符为^。2个数进行异或运算时，就是将这2个数的二进制进行异或操作， 只要2个数对应的位相同，该位运算结果为0，否则运算结果为1。即：1^1=0;1^0=1;0^0=0. 比如计算15^10，首先15的二进制为：1111，10的二进制为1010，所以15^10为： 所以15^10=5。

5，右移运算符：>>

右移运算符为>>。将一个数a向右移动n位记为：a>>n。比如将12向右移动2位如何计算呢？12的二进制为00001100，那么右移动2位为：00000011，即3。 即12>>2为3。 

右移动运算分为两种右移，一种为逻辑右移，在移动过程中，左边位用0填充。一种为算术右移，在移动过程中，左边用符号位来填充。 比如对于有符号数：10000011，对于逻辑右移，向右移动3位，那么左边用0填充，变成了：00010000。而对于算术右移，向右移动3位，那么左边用1（1为符号位）填充，变成了11110000。而对于01000011，算术右移3位，那么左边用0（0为符号位）填充，变成了00001000。 在C语言中，右移运算符为算术右移运算符，即左边用符号位来填充。

6，左移运算符：《

左移运算符为《。将一个数a向左移动n位记为：a《n。 比如将12向左移动2位如何计算呢？12的二进制为00001100，那么左移动2位为：00110000。 无论左移还是右移，都需要用0或者1去填充移动之后空位。在左移的过程中，右边一律用0去填充。左移就没有右移那样分为逻辑右移和算术右移。 比如，将10左移2位，由于10的二进制为：00001010，那么左移2位，右边用零填充的结果为：00101000。 将一个数左移N位相当于将一个数乘以2^N，而将一个数右移N位相当于将这个数除以2^N。 

位运算运算符的优先级如下：(优先级由高到低排列）
而所有的C运算符的优先级与结合律如下图：（从图中可以看出，算术运算符的优先级高于《和》运算符） 一些常见的二进制位的变换操作如下图：
在实际的编程过程中，往往会用一个整数的不同位表示不同的数据信息。在访问该整数时，就需要通过位运算来获得或者改变整数的某几位数值。比如在Windows中创建文件时使用的Create数据结构： 
struct 
{
     PIO_SECURITY_CONTEXT SecurityContext; 
    ULONG Options; 
    USHORT POINTER_ALIGNMENT FileAttributes; 
    USHORT ShareAccess;
    ULONG POINTER_ALIGNMENT EaLength;
    PVOID EaBuffer; 
    LARGE_INTEGER AllocationSize;
 } Create; 
通常会引用其中的Options如下： 
Data->Iopb->Parameters.Create.Options 
ULONG Options是一个Windows文件创建过程中的无符号长整数，指示在创建和打开文件时的不同选项。其中高8位指示了CreateDisposition参数（如FILE_OPEN，FILE_CREATE)，低24位指示了CreateOptions参数（如FILE_DELETE_ON_CLOSE)。 为了得到CreateDisposition的值，采取下面的位操作：
 (Data->Iopb->Parameters.Create.Options >> 24) & 0x000000ff; 
将该整数右移24位，再与0xff做与操作，即可获得CreateDisposition的值。
 

二，位运算应用

1．任何一个数和0异或是它的本身，和自身异或为0：

a^0=a 
a^a=0 
利用上述性质，可以用来计算2个数的交换。
大家应该知道，在计算机里，两个数互相交换，需要定义一个中间的变量来参与交换。如： 
int tmp; 
int a=10; 
int b=20; 
tmp=a; 
a=b; 
b=tmp; 
上述代码计算之后，a和b的值完成交换，a的值为20，b的值为10。 
如果用异或运算来交换2个数，可以如下方法： 
int a=10; 
int b=20; 
a=a^b; 
b=a^b; 
a=a^b; 
上述运行之后，a和b依然完成了值的交换，但由于是异或位运算，所以效率比上面的代码要高。 
证明：
a=10^20
b=a^b=(10^20)^20=10^20^20=10^0=10
a=a^b=10^20^10=10^10^20=0^20=20
把上述代码，可以封装为一个交换2个数的函数如下： 
void swap(int *a, int *b) 
{ 
    *a = *a ^ *b; 
    *b = *a ^ *b; 
    *a = *a ^ *b;
 }
 

2.将整数的第n位置位或清零：

#define BITN (1《n) 
置位：a |= BITN; 
清零：a &= ~BITN

3.清除整数a最右边的1。

方法：a & (a – 1)//该运算将会清除掉整数a二进制中最右边的1。 
问题：如何判断判断整数x的二进制中含有多少个1？ 
分析：此题是微软公司的一道笔试题。下面用&运算来解决此题。 代码如下： 
int func(int x ) 
{
    int countx = 0; 
    while ( x ) 
    { 
        countx++; 
        x = x&(x-1); 
    } 
    return countx; 
}

4.用异或运算设计一个只有一个指针域的双向链表：

 

提示： 
要实现该设计要求，需要记住链表的头结点和尾结点，并在链表结点的的next域存放前一个结点和后一个结点的异或值。即： 
p->next=pl^pr;//头结点的左边结点为NULL，尾结点的右边结点为NULL。 
在遍历的时候，从头结点往右遍历的方法： 
pl=NULL;
p=Head; 
while(p!=Tail) 
{ 
    pr=pl^(p->next); 
    pl=p; 
    p=pr;
 } 
从尾结点往左遍历的方法： 
pr=NULL; 
p=Tail; 
while(p!=Tail)
{ 
    pl=pr^(p->next); 
    pr=p; 
    p=pl; 
} 

5.计算下面表达式的值

(char)(127<<1)+1
(char)(-1>>1)+1
1<<2+3

解答：
(char)(127<<1)+1=(01111111<<1)+1=11111110+1=11111111=-1
(char)(-1>>1)+1=(11111111>>1)+1=11111111+1=0
1<<2+3=1<<(2+3)=1<<5=2^5=32(注意《和+的优先级）