这个程序是把一个文件中的二进制数字以8位为一个单位，进行读取，然后进行unicode转义，最后把转义的字符写入另外一个文件
 
 
 
  
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * 二级制转为字符码
 */
public class BinarytoChar {
	static int count = 0;
	static int charTemp = 0;
	File keyFile = new File("D:/Java/keytest.txt");
	FileInputStream fin;
	File keyOut = new File("D:/Java/output.txt");
	RandomAccessFile raf;

	public BinarytoChar() throws IOException {
		raf = new RandomAccessFile(keyOut, "rw");
	}

	/**
	 * 处理的主函数，包括读取文件的字节流
	 * 
	 * @throws IOException
	 */
	void key() throws IOException {
		byte buffer[] = new byte[2];
		fin = new FileInputStream(keyFile);
		while ((fin.read(buffer, 0, 1)) != -1) {
			readByte(buffer[0]);
		}
		/* 下边的代码还需要执行一次写入，因为readByte()函数最后一次没有执行写入 */
		char ch = (char) charTemp;
		raf.seek(raf.length());
		raf.writeByte(ch);
	}

	/**
	 * 传入的是从文件字节流读出的字节，然后处理后写入文件里，使用 & 消去高四位，为递归处理
	 * 
	 * @param by
	 *            输入的字节，从文件读出的字节为6位二进制，格式为<b>11_XXXX</b>
	 * @throws IOException
	 */
	void readByte(byte by) throws IOException {
		if (count < 8) {
			by &= 0b001111; // 高位置零
			int x = (int) by;
			charTemp += x * (int) Math.pow(2, 7 - count);
			count++;
		} else {
			char ch = (char) charTemp;
			raf.seek(raf.length());
			raf.writeByte(ch);
			count = 0;
			charTemp = 0;
			readByte(by);
		}

	}

	public static void main(String[] args) {
		try {
			new BinarytoChar().key(); 
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
	}
}
 
 
 
 
　　keytest.txt中的内容是：011000010110001101100011 ，那么写入到output.txt的字符为 acc 。
 
 
 
 
 
转载于:https://www.cnblogs.com/Lowp/archive/2012/11/16/2774211.html

	二进制同十进制类似，也是一种计数方式，不过在二进制中最大的单位数字是 1（十进制中是 9），也就是说十进制中的 2 在二进制中就要写成 10 了。以此类推，例如  7 在二进制中就应该是 111。二进制是唯一能让计算机识别的信息。
	然后再说 字节。字节是计算机的最小处理单元。一个字节占 8 位，也就是说在计算机中最小可以处理 8 位的二进制数。例如 01101011 这么一个数。
	然后再说 Ascii，这全称叫“美国信息交换标准码”。因为计算机只能识别二进制数，为了让自然语言中的各个符号例如 abcd 0123 和标点符号之类的字符能让计算机处理，就必须建立这么一个标准码来翻译成计算机能识别的二进制数。刚才说了计算机的最小处理单元是 8 位的二进制数，因此这个标准码就占用了 8 位。而 8 位的二进制数能有多少个呢？你自己算一下，换成十进制是从 0 到 255。然而标准的 ascii 没有用满这 8 位，只用了 7 位（计算机处理起来仍然是按 8 位，但是实际起作用的只有 7 位），因为当时人们觉得已经足够了。于是重新算一下，7 位的二进制数换成十进制是从 0 到 127，于是 ascii 能翻译的人类语言的字符有 128 个。也就是说，128 个数每个数对应了一个人类语言中的符号。
	后来，人们发现 128 个字符远远不够，例如制表符、数学符号啊里面都没有，于是就出现了 extended ascii，就是 “扩展 ascii”。这张表在 128 个数的基础上扩展到了 256 个，于是就占满了 8 位一字节。
	再后来，信息全球化以后，人们又发现，256 个字符仍然不能表示全人类的语言，像汉字就有至少 20000 多个，于是进一步扩展了 ascii 字符表，这次扩展到了 2 个字节，也就是 16 位。那么再算一下 16 位长度的二进制数能有多少个？那是 65536 个。于是基本上够用了。这就是 Unicode 字符集
	再之后还出现了各种基于 Unicode 的编码方式，比如 UTF-8，UTF-16，GBK，GB2312 这些。这些都是字符编码，简单说就是人们又建了各种其他的码表来和 Unicode 表对应起来。
 
	例：无符号二进制110111转化成十进制数是？
	110111=1*2^0+1*2^1+1*2^2+0*2^3+1*2^4+1*2^5=1+2+4+0+16+32=55，由此55就是表示成110111的计算机编码。
 
   

a = u'\x91'#字符串，unicode编码，\x表示16进制
b = '\x91'#字符串，unicode编码，\x表示16进制
c = '‘'
print(type(a))
print(type(b))
print(a == b)#说明有没有u都表是是unicode编码的字符串
print(b == c)#说明字符的表示有2种，一种是人能看懂的字符，另一种是字符转成unicode16进制表示的字符串
print(b)
print(a)#a,b,c都是一样的，其在内存中的存储内容是一样的，只是表达的形式不同
print(ord(a))#将16进制字符转为十进制unicode编码
print(chr(ord(a)))#将unicode编码转化为字符
print(bin(ord(a)))#将该字符转化为2进制编码
print(a.encode('utf-8'))#将字符串以utf-8的编码方式转码进行传输

UNICODE字符串与二进制字符串互转
 
有时会使用到的字符串与二进制字符串互相转换。
 

 
 

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;



public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		String src = "discover1";
		String origin = "";
		char [] strs = src.toCharArray();
		
		System.out.println(Arrays.toString(strs));
		/**字符串转二进制串,调用Integer.toBinaryString(Char char)*/
		for(int i = 0; strs.length > i; i++){
			origin += Integer.toBinaryString(strs[i])  + " ";
			
		}
		System.out.println("字符串转二进制串结果" + origin);
		
		/**二进制串转字符串,
		 * 1：需要先将二进制字符串中的每一段转为CHAR类型()
		 *	  转法为：将此段二进制字符串转为INT数组，从INT数组中得到CHAR
		 *			转时应该注意每一段二进制字符串的长度能够转为一个CHAR
		 * 2：将得到的每一个CHAR组成数组，使用String.valueOf(char [] )来得到字符串
		 * */
		String [] strarray = origin.split(" ");
		char [] preToStr = new char[strarray.length];
		for(int i = 0; i < strarray.length; i++){
			preToStr[i] = binstrToChar(strarray[i]);
			
		}
		
		String s = new String(preToStr);
		System.out.println(s);
		System.out.println("二进制串转字符串结果：" + String.valueOf(preToStr));

	}
	
    // 将二进制字符串转换为char
    private static  char binstrToChar(String binStr) {  
        int[] temp = BinstrToIntArray(binStr);  
        int sum = 0;  
        for (int i = 0; i < temp.length; i++) {  
            sum += temp[temp.length - 1 - i] << i;  
        }  
        return (char) sum;  
    } 
    
 // 将二进制字符串转换成int数组
	private static int[] BinstrToIntArray(String binStr) {
		char[] temp = binStr.toCharArray();
		int[] result = new int[temp.length];
		for (int i = 0; i < temp.length; i++) {
			result[i] = temp[i] - 48;
		}
		return result;
	}

}