赫夫曼编码

一、概述

　　1、赫夫曼编码也翻译为    哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式, 属于一种程序算法
　　2、赫夫曼编码是赫哈夫曼树在电讯通信中的经典的应用之一。

　　3、赫夫曼编码广泛地用于数据文件压缩。其压缩率通常在20%～90%之间
　　4、赫夫曼码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，称之为最佳编码

二、原理

　

 

 

 

三、代码

　　

  1 public class HuffmanCode {
  2     //1. 将赫夫曼编码表存放在 Map 形式
  3     //   生成的赫夫曼编码表
  4     // 32=01, 97=100, 100=11000, 117=11001,
  5     // 101=1110, 118=11011, 105=101, 121=11010,
  6     // 106=0010, 107=1111, 108=000, 111=0011}
  7     static HashMap huffmanCodes = new HashMap<>();
  8     //2. 在生成赫夫曼编码表示，需要去拼接路径, 定义一个StringBuilder 存储某个叶子结点的路径
  9     static StringBuilder sb = new StringBuilder();
 10 
 11     public static void main(String[] args) {
 12         String content = "i like like like java do you like a java";
 13         byte[] contentBytes = content.getBytes();
 14         System.out.println(Arrays.toString(contentBytes));
 15 
 16 
 17         //3.0测试压缩
 18         String src = "Uninstall.xml";
 19         String dst = "Uninstall.zip";
 20         //zipFile(src, dst);
 21         System.out.println("压缩文件完成");
 22 
 23         //4.0测试解压文件
 24         String zipFile = "Uninstall.zip";
 25         String dstFile = "Uninstall2.xml";
 26         unZipFile(zipFile, dstFile);
 27 
 28         /*2.0
 29         //缩减的压缩，解压过程
 30         byte[] huffmanCodesBytes = huffmanZip(contentBytes);
 31         System.out.println("压缩后的结果是:" + Arrays.toString(huffmanCodesBytes) + " 长度= " + huffmanCodesBytes.length);
 32 
 33         byte[] sourceBytes = decode(huffmanCodes, huffmanCodesBytes);
 34         System.out.println("原来的字符串=" + new String(sourceBytes));
 35         */
 36         /*
 37         //1.0分析过程
 38 
 39         //1.1获取根据单个字符ASII一样的统计个数的list集合
 40         ArrayList nodes = getNode(contentBytes);
 41         //System.out.println(nodes);
 42         //1.2创建赫夫曼树
 43         Node huffmanTreeRoot = createHuffmanTree(nodes);
 44         //1.3前序遍历赫夫曼树
 45         huffmanTreeRoot.preOrder();
 46         //1.4生成赫夫曼编码
 47         HashMap huffmanCodes = getCodes(huffmanTreeRoot);
 48         //System.out.println(huffmanCodes);
 49         //1.5测试
 50         byte[] huffmanCodeBytes = zip(contentBytes, huffmanCodes);
 51         System.out.println(Arrays.toString(huffmanCodeBytes));
 52         */
 53     }
 54 
 55     /**
 56      * @param src 你传入的希望压缩的文件的全路径
 57      * @param dst 我们压缩后将压缩文件放到哪个目录
 58      */
 59     private static void zipFile(String src, String dst) {
 60         FileInputStream is = null;
 61         FileOutputStream fos = null;
 62         ObjectOutputStream osw = null;
 63         try {
 64 
 65             is = new FileInputStream(src);
 66             //创建一个和源文件大小一样的byte[]
 67             byte[] b = new byte[is.available()];
 68             //读取文件
 69             is.read(b);
 70             //直接对源文件压缩
 71             byte[] huffmanBytes = huffmanZip(b);
 72             //创建文件的输出流, 存放压缩文件
 73             fos = new FileOutputStream(dst);
 74             //创建一个和文件输出流关联的ObjectOutputStream
 75             osw = new ObjectOutputStream(fos);
 76             //把 赫夫曼编码后的字节数组写入压缩文件
 77             osw.writeObject(huffmanBytes);
 78             //这里我们以对象流的方式写入 赫夫曼编码，是为了以后我们恢复源文件时使用
 79             //注意一定要把赫夫曼编码 写入压缩文件
 80             osw.writeObject(huffmanCodes);
 81 
 82         } catch (IOException e) {
 83             System.out.println(e.getMessage());
 84         } finally {
 85             try {
 86                 if (is != null)
 87                     is.close();
 88             } catch (IOException e) {
 89                 e.printStackTrace();
 90             }
 91             try {
 92                 if (osw != null)
 93                     osw.close();
 94             } catch (IOException e) {
 95                 e.printStackTrace();
 96             }
 97             try {
 98                 if (fos != null)
 99                     fos.close();
100             } catch (IOException e) {
101                 e.printStackTrace();
102             }
103         }
104     }
105 
106     /**
107      * @param zipFile 准备解压的文件
108      * @param dstFile 将文件解压到哪个路径
109      */
110     private static void unZipFile(String zipFile, String dstFile) {
111 
112         FileInputStream fis = null;
113         ObjectInputStream ois = null;
114         FileOutputStream fos = null;
115         try {
116             fis = new FileInputStream(zipFile);
117             ois = new ObjectInputStream(fis);
118             //读取byte数组  huffmanBytes
119             byte[] huffmanBytes = (byte[]) ois.readObject();
120             //读取赫夫曼编码表
121             HashMap huffmanCodes = (HashMap) ois.readObject();
122             //解码
123             byte[] bytes = decode(huffmanCodes, huffmanBytes);
124             //将bytes 数组写入到目标文件
125             fos = new FileOutputStream(dstFile);
126             //写数据到 dstFile 文件
127             fos.write(bytes);
128         } catch (Exception e) {
129             System.out.println(e.getMessage());
130         } finally {
131             try {
132                 if (fis != null) {
133                     fis.close();
134                 }
135             } catch (IOException e) {
136                 e.printStackTrace();
137             }
138             try {
139                 if (ois != null) {
140                     ois.close();
141                 }
142             } catch (IOException e) {
143                 e.printStackTrace();
144             }
145             try {
146                 if (fos != null) {
147                     fos.close();
148                 }
149             } catch (IOException e) {
150                 e.printStackTrace();
151             }
152         }
153     }
154 
155 
156     //完成数据的解压
157     //思路
158     //1. 将huffmanCodeBytes [-88, -65, -56, -65, -56, -65, -55, 77, -57, 6, -24, -14, -117, -4, -60, -90, 28]
159     //   重写先转成 赫夫曼编码对应的二进制的字符串 "1010100010111..."
160     //2.  赫夫曼编码对应的二进制的字符串 "1010100010111..." =》 对照 赫夫曼编码  =》 "i like like like java do you like a java"
161 
162     //编写一个方法，完成对压缩数据的解码
163 
164     /**
165      * @param huffmanCodes 赫夫曼编码表 map
166      * @param huffmanBytes 赫夫曼编码得到的字节数组
167      * @return 就是原来的字符串对应的数组
168      */
169     private static byte[] decode(Map huffmanCodes, byte[] huffmanBytes) {
170 
171         //1. 先得到 huffmanBytes 对应的 二进制的字符串 ， 形式 1010100010111...
172         StringBuilder stringBuilder = new StringBuilder();
173         //将byte数组转成二进制的字符串
174         for (int i = 0; i < huffmanBytes.length; i++) {
175             byte b = huffmanBytes[i];
176             //判断是不是最后一个字节
177             boolean flag = (i == huffmanBytes.length - 1);
178             stringBuilder.append(byteToBitString(!flag, b));
179         }
180         //把字符串安装指定的赫夫曼编码进行解码
181         //把赫夫曼编码表进行调换，因为反向查询 a->100 100->a
182         Map map = new HashMap();
183         for (Map.Entry entry : huffmanCodes.entrySet()) {
184             map.put(entry.getValue(), entry.getKey());
185         }
186 
187         //创建要给集合，存放byte
188         List list = new ArrayList<>();
189         //i 可以理解成就是索引,扫描 stringBuilder
190         for (int i = 0; i < stringBuilder.length(); ) {
191             int count = 1; // 小的计数器
192             boolean flag = true;
193             Byte b = null;
194 
195             while (flag) {
196                 //1010100010111...
197                 //递增的取出 key 1
198                 String key = stringBuilder.substring(i, i + count);//i 不动，让count移动，指定匹配到一个字符
199                 b = map.get(key);
200                 if (b == null) {//说明没有匹配到
201                     count++;
202                 } else {
203                     //匹配到
204                     flag = false;
205                 }
206             }
207             list.add(b);
208             i += count;//i 直接移动到 count
209         }
210         //当for循环结束后，我们list中就存放了所有的字符  "i like like like java do you like a java"
211         //把list 中的数据放入到byte[] 并返回
212         byte b[] = new byte[list.size()];
213         for (int i = 0; i < b.length; i++) {
214             b[i] = list.get(i);
215         }
216         return b;
217 
218     }
219 
220     /**
221      * 将一个byte 转成一个二进制的字符串, 如果看不懂，可以参考我讲的Java基础 二进制的原码，反码，补码
222      *
223      * @param b    传入的 byte
224      * @param flag 标志是否需要补高位如果是true ，表示需要补高位，如果是false表示不补, 如果是最后一个字节，无需补高位
225      * @return 是该b 对应的二进制的字符串，（注意是按补码返回）
226      */
227     private static String byteToBitString(boolean flag, byte b) {
228         //使用变量保存 b
229         int temp = b;//将 b 转成 int
230         //如果是正数我们还存在补高位
231         if (flag) {
232             temp |= 256;//按位与 256  1 0000 0000  | 0000 0001 => 1 0000 0001
233         }
234         String str = Integer.toBinaryString(temp);
235         if (flag) {
236             return str.substring(str.length() - 8);
237         } else {
238             return str;
239         }
240     }
241     //使用一个方法，将前面的方法封装起来，便于我们的调用.
242 
243     /**
244      * @param bytes 原始的字符串对应的字节数组
245      * @return 是经过 赫夫曼编码处理后的字节数组(压缩后的数组)
246      */
247     private static byte[] huffmanZip(byte[] bytes) {
248         ArrayList nodes = getNode(bytes);
249         //根据 nodes 创建的赫夫曼树
250         Node huffmanTreeRoot = createHuffmanTree(nodes);
251         //对应的赫夫曼编码(根据 赫夫曼树)
252         HashMap huffmanCodes = getCodes(huffmanTreeRoot);
253         //根据生成的赫夫曼编码，压缩得到压缩后的赫夫曼编码字节数组
254         byte[] huffmanCodeBytes = zip(bytes, huffmanCodes);
255         return huffmanCodeBytes;
256     }
257 
258     /**
259      * 编写一个方法，将字符串对应的byte[] 数组，通过生成的赫夫曼编码表，返回一个赫夫曼编码 压缩后的byte[]
260      *
261      * @param bytes        这时原始的字符串对应的 byte[]
262      * @param huffmanCodes 生成的赫夫曼编码map
263      * @return 返回赫夫曼编码处理后的 byte[]
264      * 举例： String content = "i like like like java do you like a java"; =》 byte[] contentBytes = content.getBytes();
265      * 返回的是 字符串 "1010100010111111110010001011111111001000101111111100100101001101110001110000011011101000111100101000101111111100110001001010011011100"
266      * => 对应的 byte[] huffmanCodeBytes  ，即 8位对应一个 byte,放入到 huffmanCodeBytes
267      * huffmanCodeBytes[0] =  10101000(补码) => byte  [推导  10101000=> 10101000 - 1 => 10100111(反码)=> 11011000= -88 ]
268      * huffmanCodeBytes[1] = -88
269      */
270     private static byte[] zip(byte[] bytes, HashMap huffmanCodes) {
271         StringBuilder stringBuilder = new StringBuilder();
272         for (byte b : bytes) {
273             stringBuilder.append(huffmanCodes.get(b));
274         }
275         //System.out.println(stringBuilder);
276         //统计返回  byte[] huffmanCodeBytes 长度
277         //一句话 int len = (stringBuilder.length() + 7) / 8;
278         int len;
279         if (stringBuilder.length() % 8 == 0) {
280             len = stringBuilder.length() / 8;
281         } else {
282             len = stringBuilder.length() / 8 + 1;
283         }
284         byte[] huffmanCodeBytes = new byte[len];
285         int index = 0;
286         for (int i = 0; i < stringBuilder.length(); i += 8) {
287             String b;
288             if (i + 8 > stringBuilder.length()) {
289                 b = stringBuilder.substring(i);
290             } else {
291                 b = stringBuilder.substring(i, i + 8);
292             }
293             //将strByte 转成一个byte,放入到 huffmanCodeBytes
294             huffmanCodeBytes[index] = (byte) Integer.parseInt(b, 2);
295             index++;
296         }
297         return huffmanCodeBytes;
298     }
299 
300     private static HashMap getCodes(Node root) {
301         if (root == null) {
302             return null;
303         }
304         //处理root的左子树
305         getCodes(root.left, "0", sb);
306         //处理root的右子树
307         getCodes(root.right, "1", sb);
308         return huffmanCodes;
309     }
310 
311     /**
312      * 功能：将传入的node结点的所有叶子结点的赫夫曼编码得到，并放入到huffmanCodes集合
313      *
314      * @param node 传入结点
315      * @param code 路径： 左子结点是 0, 右子结点 1
316      * @param sb   用于拼接路径
317      */
318     private static void getCodes(Node node, String code, StringBuilder sb) {
319         StringBuilder sbb = new StringBuilder(sb);
320         sbb.append(code);
321         if (node != null) {
322             //判断当前node 是叶子结点还是非叶子结点
323             if (node.data == null) {//非叶子结点,不存数据data
324                 //向左递归
325                 getCodes(node.left, "0", sbb);
326                 //向右递归
327                 getCodes(node.right, "1", sbb);
328             } else {//说明是一个叶子结点
329                 //就表示找到某个叶子结点的最后
330                 huffmanCodes.put(node.data, sbb.toString());
331             }
332         }
333     }
334 
335     //可以通过List 创建对应的赫夫曼树
336     private static Node createHuffmanTree(ArrayList nodes) {
337 
338         while (nodes.size() > 1) {
339             //每次添加完节点，并且删除原来的节点后，是乱序的，只能每次循环都要排序
340             Collections.sort(nodes);
341             //取出第一颗最小的二叉树
342             Node left = nodes.get(0);
343             //取出第二颗最小的二叉树
344             Node right = nodes.get(1);
345             //创建一颗新的二叉树,它的根节点 没有data, 只有权值
346             Node parent = new Node(null, left.weight + right.weight);
347 
348             parent.left = left;
349             parent.right = right;
350             //将已经处理的两颗二叉树从nodes删除
351             nodes.remove(left);
352             nodes.remove(right);
353             //将新的二叉树，加入到nodes
354             nodes.add(parent);
355         }
356         //nodes 最后的结点，就是赫夫曼树的根结点
357         return nodes.get(0);
358     }
359 
360     /**
361      * @param bytes 接收字节数组
362      * @return 返回的就是 List 形式   [Node[date=97 ,weight = 5], Node[]date=32,weight = 9]......],
363      */
364     private static ArrayList getNode(byte[] bytes) {
365         HashMap map = new HashMap<>();
366         for (byte b : bytes) {
367             Integer i = map.get(b);
368             if (i == null) {
369                 map.put(b, 1);
370             } else
371                 map.put(b, ++i);
372         }
373         ArrayList list = new ArrayList<>();
374         for (Map.Entry entry : map.entrySet()) {
375             list.add(new Node(entry.getKey(), entry.getValue()));
376         }
377 
378         return list;
379     }
380 }
381 
382 class Node implements Comparable {
383     // 存放数据(字符)本身，比如'a' => 97 ' ' => 32
384     Byte data;
385     //权值, 表示字符出现的次数
386     int weight;
387     Node left;
388     Node right;
389 
390     public Node(Byte data, int weight) {
391         this.data = data;
392         this.weight = weight;
393     }
394 
395 
396     @Override
397     public String toString() {
398         return "Node{" +
399                 "data=" + data +
400                 ", weight=" + weight +
401                 '}';
402     }
403 
404     @Override
405     public int compareTo(Node o) {
406         return this.weight - o.weight;
407     }
408 
409     public void preOrder() {
410         System.out.println(this);
411         if (this.left != null) {
412             this.left.preOrder();
413         }
414         if (this.right != null) {
415             this.right.preOrder();
416         }
417     }
418 }