哈夫曼压缩

一、压缩

思路：一个文件中，都会出现重复的字节，有些字节出现的次数多，有些字节出现的次数少，这样我们就可以根据出现次数的多少，构造哈夫曼树，并进行编码，出现次数越多的编码长度越短，出现次数越少的编码长度越长。而我们有知道一个英文字母占用一个byte，一个中文占用两个byte。我们将文件中的字节化为对应的编码后，形成01串，每次取八个01串写入压缩后的文件。因为编码的长度大多情况下都比文件中数据占用bit数更少，所以就文件就压缩了。

具体步骤：

①、统计文件中字节出现的次数

②、根据次数构建哈弗曼树

③、获取每个结点的哈弗曼编码

④将字节用01字符数组表示

 

 

/**
 * 压缩编码表元素
 * @author hpw
 *
 */
public class CodeTableNode {
	private byte bt;
	private Byte[] code;
	/**
	 * 构造器，传入一个byte和代表这个byte的int数组code，code每个元素代表一个二进制位
	 * 只有0，1
	 * @param bt  传入的byte
	 * @param code2  对应byte的二进制编码
	 */
	public CodeTableNode(byte bt,Byte[] code2){
		this.bt=bt;
		this.code=code2;
	}
	public byte getByte() {
		return bt;
	}
	public Byte[] getCode() {
		return code;
	}
}

 

 

	/**
	 * 建立数组的方法（TreeNodeArray：类似优先队列的方法）
	 * 
	 * @return 根据byte出现次数进行排序的数组
	 * @throws IOException
	 */
	private TreeNodeArray getList() throws IOException {
		TreeNodeArray tList = new TreeNodeArray();
		// 创建输入输出流
		java.io.InputStream inputStr = new java.io.FileInputStream(file);
		java.io.BufferedInputStream bus=new java.io.BufferedInputStream(inputStr,2048);
		int bt=bus.read();
		while(bt!=-1){
			byte by=(byte)bt;
			TreeNode node = new TreeNode(by);
			tList.add(node);
			bt=bus.read();
		}
		inputStr.close();// 关闭输入流
		bus.close();
		
		return tList;
	}

	/**
	 * 通过节点队列创建二叉树，取出前2个节点组成二叉树，将根节点排序插入到队列中，
	 * 如此循环，最后剩下的就是根节点
	 * 
	 * @return 二叉树头节点
	 * @throws Exception
	 */
	public TreeNode getTree() throws Exception {

		TreeNodeArray list = getList();

		while (list.size() > 1) {
			TreeNode LNode = list.remove(0);
			TreeNode RNode = list.remove(0);

			TreeNode NNode = new TreeNode(LNode, RNode);
			
			list.insert(NNode);
		}
		TreeNode rootNode = list.get(0);
		
		return rootNode;
	}
	
	/**
	 * 生成编码表方法
	 * @return  CodeMap格式的编码表
	 * @throws Exception
	 */
	public CodeTable getMap() throws Exception{
		
		TreeNode rootNode=this.getTree();
		//遍历树
		TreeStack<Byte> rootStack=new TreeStack<Byte>();//堆栈记录路径
		CodeTable codes=new CodeTable();
		scanTree(rootNode,rootStack,codes);
		
		return codes;
	}
	
	/**
	 * 遍历树的方法，递归
	 * @param root  节点
	 * @param rootStk  堆栈记录，存储路径
	 * @param map   编码表
	 */
	private void scanTree(TreeNode root,TreeStack<Byte> rootStk,CodeTable map){
		if(root.getType()==1){
			//根节点
			TreeNode LNode=root.getLNode();
			rootStk.add((byte)0);
			//递归遍历左节点
			scanTree(LNode,rootStk,map);
			TreeNode RNode=root.getRNode();
			rootStk.add((byte)1);
			//递归遍历右节点
			scanTree(RNode,rootStk,map);
		}
		if(root.getType()==2){
			//叶节点
			Object[] cd=rootStk.getCode();
			Byte[] code=new Byte[cd.length];
			int ind=0;
			for(Object o:cd){
				byte ob=(Byte)o;
				code[ind]=ob;
				ind++;
			}
			byte bt=root.getB();
			CodeTableNode nd=new CodeTableNode(bt,code);
			map.add(nd);
		}
		rootStk.pop();//栈回溯
	}

 

⑤、每个取一个长度为八的字节数组，写入文件，若最后剩下的数组不足八位，则添加码表中没有的元素知道够8位。并写入码表

 

/**

	 * 获取文件重新编码,并直接写入文件
	 * 
	 * @param file
	 *            文件对象
	 * @param map
	 *            编码表
	 * @throws Exception
	 */
	private void getFileCode(File file, OutputStream op, CodeTable map)
			throws Exception {
		java.io.InputStream in = new java.io.FileInputStream(file);
		Byte[] nBt = new Byte[8];// 储存字节的每位，8位
		int emptyN = 8;// 剩余的空位，候补
		int btn = in.read();
		while (btn != -1) {
			byte bn = (byte) btn;
			Byte[] code = map.get(bn);// 获取b对应的编码
			for (int t = 0; t < code.length; t++) {// 插入值到bit位数组中
				nBt[8 - emptyN] = code[t];
				emptyN--;
				// 写满一个字节后加入队列
				if (emptyN == 0) {
					byte nByte = toByte(nBt);
					// 写入文件
					System.out.println("写入byte："+nByte);
					byte[] bt = { nByte };
					op.write(bt);
					emptyN = 8;// 空位重置
					nBt = new Byte[8];// 数组重置
				}
			}
			btn = in.read();
		}
		in.close();
		// 写完后检测是否写满最后一个字节，如未满则填充一个map中不存在的值
		if (emptyN > 0) {
			Byte[] addCode = new Byte[emptyN];
			// 检测到可行的结尾填充
			if (scanUsableAddons(map, addCode, 0)) {
				for (byte bi : addCode) {
					nBt[8 - emptyN] = bi;
					emptyN--;
				}
				byte endB = toByte(nBt);
				// 添加到重新编码区结尾
				byte[] bt = { endB };
				op.write(bt);
			}
		}
	}

 /**

	 * 将CodeMap编码表对象转换成byte数组 规则：
	 * 每条编码为3部分，第一部分占1个byte，储存编码的， 第二部分占一个byte，存储原byte值
	 * 第三部分为一个byte[]数组，储存对应的编码，每个二进制位占一个byte,只为0或1
	 * 
	 * @param map
	 *            传入一个CodeMap对象
	 * @return 转换完成的byte数组
	 */
	private byte[] getMapByte(CodeTable map) {
		List<Byte> allBy = new ArrayList<Byte>();
		for (CodeTableNode mNode : map.getAllNodes()) {
			// 取得map中MapNode对象
			byte bt = mNode.getByte();// 取得byte值
			Byte[] co = mNode.getCode();// 取得编码
			Byte len = (byte) co.length;// 取得编码长度
			allBy.add(len);
			allBy.add(bt);
			for (byte b : co) {// 取得编码中每个二进制位值传入队列
				allBy.add(b);
			}
		}
		// 转换队列为byte[]数组
		byte[] abts = new byte[allBy.size()];
		int index = 0;
		for (byte b : allBy) {
			abts[index] = b;
			index++;
		}
		return abts;
	}

 

 

private void compress() {
		String src = srcField.getText();
		String tar = tarField.getText();
		File srcFile = new File(src);
		File tarFile = new File(tar);
		
		lab.setText("开始压缩   O(∩_∩)O");
		//lab.setText("正在压缩。。。  →_→");
		
		ReadFile sf = new ReadFile(srcFile);
		CodeTable map = null;// 获取编码表
		
		try {
			//得到码表
			map = sf.getMap();
			byte[] maptoByte = getMapByte(map);

			tarFile.createNewFile();// 创建文件
			// 建立输出流
			java.io.OutputStream out = new java.io.FileOutputStream(tarFile);
			// 建立对象输出流
			int mapLen = maptoByte.length;
			java.io.DataOutputStream dou = new java.io.DataOutputStream(out);
			dou.writeInt(mapLen);
			dou.flush();
			// 输出编码表
			out.write(maptoByte);
			
			// 写入转码后的文件数据
//			lab.setText("正在压缩。。。  →_→");
			
			getFileCode(srcFile, out, map);// 直接队文件转码并写入
			out.flush();
			out.close();
			
			//lab.setText("压缩成功！  (^o^)");
		} catch (Exception e1) {
			e1.printStackTrace();
		}
	}

 

 

二、解压

思路：从压缩的文件中读取字节+码表，将每个字节转化为一个八位的字符数组，逐一对比码表，若有相同的则根据码表转化为相应的字节，若没有一致的，则继续读取字节化为八位的字数数组，如此循环，知道读取完文件。然后将获取的字节写入文件，这样解压就算完成了。其实解压是压缩的逆过程，关键就是写入码表与获取码表，这是压缩与解压万和城呢过的关键。

 

/**

	 * 解压方法，先获取编码表，再对文件进行解码
	 * 
	 * @throws Exception
	 */
	private void inCompress() throws Exception {
		File srcF = new File(srcField.getText());
		File tarF = new File(tarField.getText());
		
//		lab.setText("开始解压   O(∩_∩)O");
		lab.setText("正在解压。。。  →_→");
		tarF.createNewFile();
		java.io.InputStream inStr = new java.io.FileInputStream(srcF);
		java.io.DataInputStream daIns = new java.io.DataInputStream(inStr);
		java.io.OutputStream ouStr = new java.io.FileOutputStream(tarF);
		
		// 取得编码表的长度
		int byteCount = daIns.readInt();
		int readByte = inStr.read();
		byteCount--;
		CodeTable getMap = new CodeTable();// 编码表对象，备用
		
		while (byteCount > 0) {
			int readCount = readByte;// 读取时的计数变量，以确定当前读取的数据类型
			// 获取本条编码的长度为readCount
			Byte[] byteCode = new Byte[readCount];
			readByte = inStr.read();
			byteCount--;// 读取了一个字节，计数器减一
			if (readByte == -1) {// 异常文件结尾,抛出
				throw new Exception("Unexcepted End");
			}
			byte bt = (byte) readByte;// 当前编码对应的字节
			for (int i = 0; i < readCount; i++) {
				readByte = inStr.read();
				byteCount--;// 读取了一个字节，计数器减一
				if (readByte == -1) {// 异常文件结尾,抛出
					throw new Exception("Unexcepted End");
				}
				byte tb = (byte) readByte;
				byteCode[i] = tb;
			}
			// 一条编码读取完毕，建立一个编码表节点对象并导入了
			CodeTableNode getNode = new CodeTableNode(bt, byteCode);
			getMap.add(getNode);
			readByte = inStr.read();
			byteCount--;// 读取下一个数据
		}
		
//		lab.setText("正在解压。。。  →_→");
		
		// 编码表建立完毕，开始读取文件正文并转码
		// 转码方法：每次读取一位，在编码表中检索，如果存在则转码，不存在则增加一位并重新检测
		List<Byte> bs = new java.util.ArrayList<Byte>();// 存储编码的byte队列
		while (readByte != -1) {
			byte b = (byte) readByte;
			
			byte[] bArray = toByteArray(b);// 将字节每位提出转成数组
			
			for (byte bn : bArray) {
				bs.add(bn);
				byte[] nNode = checkMapCode(getMap, bs);
				if (nNode != null) {
					ouStr.write(nNode);
					ouStr.flush();
					bs.clear();// 清空队列
				}
				if (bs.size() > getMap.getAllNodes().size()) {
					// 队列长度已经大于Map中的编码条数
					throw new Exception("Erro File,Not Found Code");
				}
			}
			readByte = inStr.read();// 继续读取
		}
		
//		lab.setText("解压成功！  (^o^)");
		
		// 关闭输入输出流
		inStr.close();
		ouStr.close();
	}

 

 

/**
	 * 递归检索编码表map中无对应值的结尾二进制位作为结尾
	 * 
	 * @param map
	 *            编码表
	 * @param bits
	 *            剩余的二进制位
	 * @param index
	 *            目前的指向
	 * @return 找到了则返回true，检索完毕都未找到则返回false
	 */
	private boolean scanUsableAddons(CodeTable map, Byte[] bits, int index) {
		if (index != bits.length - 1) {
			bits[index] = 0;
			if (scanUsableAddons(map, bits, index + 1)) {
				return true;
			}
			bits[index] = 1;
			if (scanUsableAddons(map, bits, index + 1)) {
				return true;
			}
		}
		if (index == bits.length - 1) {
			bits[index] = 0;
			if (map.get(bits) == null) {
				return true;
			}
			bits[index] = 1;
			if (map.get(bits) == null) {
				return true;
			}
		}
		return false;
	}

 

三、感想

做完哈夫曼压缩后，感想最大的就是速度，速度太慢，就像蜗牛爬一样慢，相对于自己用地360压缩是简直没得比，压缩个7M多点的要16分钟，解压更是成倍增长。还有就是对于一些doc格式、ppt格式的等，压缩比也不大高，可能是文件大小的原因。

 

 

 

界面图：

 

源文件、压缩后、解压后的对比图：