Java中的位操作符

&(与)操作

两个操作数中位都为1，结果才为1，否则结果为0

public class data13 { public static void main(String[] args) { int a=129; int b=128; System.out.println("a 和b 与的结果是："+(a&b)); } }

运行结果: a 和b 与的结果是：128 下面分析这个程序： “a”的值是129，转换成二进制就是10000001，而“b”的值是128，转换成二进制就是10000000。根据与运算符的运算规律，只有两个位都是1，结果才是1，可以知道结果就是10000000，即128。

|(或)运算符

或运算符用符号“|”表示，其运算规律如下： 两个位只要有一个为1，那么结果就是1，否则就为0，下面看一个简单的例子。

public class data14 { public static void main(String[] args) { int a=129; int b=128; System.out.println("a 和b 或的结果是："+(a|b)); } }

运行结果 a 和b 或的结果是：129 下面分析这个程序段： a 的值是129，转换成二进制就是10000001，而b 的值是128，转换成二进制就是10000000，根据或运算符的运算规律，只有两个位有一个是1，结果才是1，可以知道结果就是10000001，即129。

^(异或)运算符

异或运算符是用符号“^”表示的，其运算规律是： 两个操作数的位中，相同则结果为0，不同则结果为1。下面看一个简单的例子。

public class data16 { public static void main(String[] args) { int a=15; int b=2; System.out.println("a 与 b 异或的结果是："+(a^b)); } }

运行结果 a 与 b 异或的结果是：13 分析上面的程序段：a 的值是15，转换成二进制为1111，而b 的值是2，转换成二进制为0010，根据异或的运算规律，可以得出其结果为1101 即13。

~(非)运算符

非运算符用符号“~”表示，其运算规律如下：

如果位为0，结果是1，如果位为1，结果是0，下面看一个简单例子。

public class data15 { public static void main(String[] args) { int a=2; System.out.println("a 非的结果是："+(~a)); } }

运行结果是: -3, 2的二进制表示是:0000….000010 然后取~, 结果是1111….111101, 将补码转换成十进制就是-3

<< (左移)运算符

<< 和>>为数值位移，>>>为逻辑位移。【注】:Java中不存在<<<。 m<<n的含义:把整数m表示的二进制数左移n位,高位移出n位都舍弃，低位补0. (此时将会出现正数变成负数的形式)

3<<2剖析：

3的二进制形式: 00000000 00000000 00000000 00000011,按照左移的原理，得到00000000 00000000 00000000 00001100,即为12. 左移使整数变为负数:

10737418<<8

10737418二进制表示形式:00000000 10100011 11010111 00001010,按照左移的原理，得到10100011 11010111 00001010 00000000，即为:-1546188288.

>>(逻辑右移)运算符

m>>n的含义:把整数m表示的二进制数右移n位,m为正数，高位全部补0；m为负数，高位全部补1. >> 会根据符号位的正负进行补位

3>>2剖析：

3二进制形式: 00000000 00000000 00000000 00000011,按照右移的原理，得到00000000 00000000 00000000 00000000,即为0. -3>>2剖析： -3二进制形式: 11111111 11111111 11111111 11111101,按照右移的原理，得到11111111 11111111 11111111 11111111,即为-1.

以上:每 个整数表示的二进制都是32位的，如果右移32位和右移0位的效果是一样的。依次类推，右移32的倍数位都一样。

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

m>>>n：整数m表示的二进制右移n位，不论正负数，高位都补零。

3>>>2剖析：

3二进制形式: 00000000 00000000 00000000 00000011,按照无符号右移的原理，得到00000000 00000000 00000000 00000000,即为0. -3>>>2剖析： -3二进制形式: 11111111 11111111 11111111 11111101,按照无符号右移的原理，得到00111111 11111111 11111111 11111111,即为1073741823.

---

&0xFF的意义

byte类型转换成int类型时需要进行 &0xFF的操作, 原因跟计算机的存储原理有关。

数据在内存是以补码的形式存在的。 补码： 正数（000000001）： 正数的补码和反码都是它本身。 负数（100000001）: 反码是对原码除了符号位之外作取反运算即（111111110），补码是对反码作+1运算即（111111111）。

System.out.println(-127 & 0xFF); // 结果是129

下面分析-127&0xFF的过程

-127的补码表示(10000001)

JVM向控制台输出时，检测到byte向int类型的转换于是做了一个补位处理 (10000001) -> (11111111,11111111,11111111,10000001) 这个32位的补码表示也是-127, 此时转换过后的二进制数据的十进制表示仍然是相同的,但是此时补码的因为高位补1已经不一致了,我们为了保证补码的一致性,必须进行&0xFF操作.

进行&0xFF操作 &0xff可以将高的24位置为0，低8位保持原样。这样做的目的就是为了保证二进制数据的一致性。 当然，保证了二进制数据性的同时，如果二进制被当作byte和int来解读，其10进制的值必然是不同的，因为符号位位置已经发生了变化。 比如-127&0xff; -127 & 0xff=(11111111,11111111,111111111,10000001) & (00000000,00000000,00000000,11111111) = (00000000,00000000,00000000,10000001) 这个值算一下就是129.

// & 0xFF 的区别 System.out.println(Integer.toBinaryString(-127)); System.out.println(Integer.toBinaryString(-127 & 0xFF)); // 11111111111111111111111110000001 // 10000001

Java实现int和long类型的序列化

简单对上面的知识进行一个总结 这个小demo就是将int和long类型的数值写到文件中,然后在读出来,如果结果正确证明序列化成功.

创建文件

private static void createFile() { sFile = new File("./", "obj"); sFile.delete(); if (!sFile.exists()) { try { sFile.createNewFile(); } catch (IOException e) { e.printStackTrace(); } } }

int类型的序列化

int类型占8个字节,每次右移8个单位存储,需要分四次写入

// 将int数据写到硬盘上 private static void writeInt(int num) throws IOException { BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(sFile)); bos.write((num >> 0) & 0xFF); bos.write((num >> 8) & 0xFF); bos.write((num >> 16) & 0xFF); bos.write((num >> 24) & 0xFF); bos.flush(); bos.close(); } // 同样也是分四次读,每次获取8位数据,然后读四次 // 从文件中读取int类型的值 private static int readInt() throws IOException { BufferedInputStream bis = new BufferedInputStream(new FileInputStream(sFile)); int num = 0; num |= bis.read(); num |= bis.read() << 8; num |= bis.read() << 16; num |= bis.read() << 24; bis.close(); return num; }

long类型的序列化

// long类型在JVM运行时占用8个字节,也就是64位,所以我们需要分8次向文件中写入数据 private static void writeLong(long num) throws IOException { BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(sFile)); bos.write((int) ((num >> 0) & 0xFFL)); bos.write((int) ((num >> 8) & 0xFFL)); bos.write((int) ((num >> 16) & 0xFFL)); bos.write((int) ((num >> 24) & 0xFFL)); bos.write((int) ((num >> 32) & 0xFFL)); bos.write((int) ((num >> 40) & 0xFFL)); bos.write((int) ((num >> 48) & 0xFFL)); bos.write((int) ((num >> 56) & 0xFFL)); bos.flush(); bos.close(); } // 同样, 分8次从文件中读取数据,记得 &0xFFL 转换成long类型 private static long readLong() throws IOException { BufferedInputStream bis = new BufferedInputStream(new FileInputStream(sFile)); long num = 0L; num |= (bis.read() & 0xFFL) << 0; num |= (bis.read() & 0xFFL) << 8; num |= (bis.read() & 0xFFL) << 16; num |= (bis.read() & 0xFFL) << 24; num |= (bis.read() & 0xFFL) << 32; num |= (bis.read() & 0xFFL) << 40; num |= (bis.read() & 0xFFL) << 48; num |= (bis.read() & 0xFFL) << 56; bis.close(); return num; }

测试代码

private static void serialIntTest() throws IOException { final int magic = -0x20170507; System.out.println("序列化前: " + magic); writeInt(magic); System.out.println("序列化后: " + readInt()); } private static void serialLongTest() throws IOException{ // 如果是long类型,那么数字结尾处必须加上L,否则会认为是int类型 final long magicLong = -0x2017050720170507L; System.out.println("序列化前: " + magicLong); writeLong(magicLong); System.out.println("序列化后: " + readLong()); }

完整代码

/** * Created by yangtianrui on 17-5-7. */ public class WriteByteToFile { private static File sFile; public static void main(String[] args) throws Exception { createFile(); serialIntTest(); serialLongTest(); /* * 结果: * 序列化前: -538379527 * 序列化后: -538379527 * 序列化前: -2312322461839328519 * 序列化后: -2312322461839328519 */ } private static void serialIntTest() throws IOException { final int magic = -0x20170507; System.out.println("序列化前: " + magic); writeInt(magic); System.out.println("序列化后: " + readInt()); } private static void serialLongTest() throws IOException{ // 如果是long类型,那么数字结尾处必须加上L,否则会认为是int类型 final long magicLong = -0x2017050720170507L; System.out.println("序列化前: " + magicLong); writeLong(magicLong); System.out.println("序列化后: " + readLong()); } private static void writeInt(int num) throws IOException { BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(sFile)); bos.write((num >> 0) & 0xFF); bos.write((num >> 8) & 0xFF); bos.write((num >> 16) & 0xFF); bos.write((num >> 24) & 0xFF); bos.flush(); bos.close(); } private static int readInt() throws IOException { BufferedInputStream bis = new BufferedInputStream(new FileInputStream(sFile)); int num = 0; num |= bis.read(); num |= bis.read() << 8; num |= bis.read() << 16; num |= bis.read() << 24; bis.close(); return num; } private static void writeLong(long num) throws IOException { BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(sFile)); bos.write((int) ((num >> 0) & 0xFFL)); bos.write((int) ((num >> 8) & 0xFFL)); bos.write((int) ((num >> 16) & 0xFFL)); bos.write((int) ((num >> 24) & 0xFFL)); bos.write((int) ((num >> 32) & 0xFFL)); bos.write((int) ((num >> 40) & 0xFFL)); bos.write((int) ((num >> 48) & 0xFFL)); bos.write((int) ((num >> 56) & 0xFFL)); bos.flush(); bos.close(); } private static long readLong() throws IOException { BufferedInputStream bis = new BufferedInputStream(new FileInputStream(sFile)); long num = 0L; num |= (bis.read() & 0xFFL) << 0; num |= (bis.read() & 0xFFL) << 8; num |= (bis.read() & 0xFFL) << 16; num |= (bis.read() & 0xFFL) << 24; num |= (bis.read() & 0xFFL) << 32; num |= (bis.read() & 0xFFL) << 40; num |= (bis.read() & 0xFFL) << 48; num |= (bis.read() & 0xFFL) << 56; bis.close(); return num; } private static void createFile() { sFile = new File("./", "obj"); sFile.delete(); if (!sFile.exists()) { try { sFile.createNewFile(); } catch (IOException e) { e.printStackTrace(); } } } }