逛奔的蜗牛

我不聪明，但我会很努力
   ::  :: 新随笔 ::  ::  :: 管理 ::
Java：自己动手写压缩软件，超详细解释（哈夫曼实现）

说到文件压缩大家很容易想到的就是 rar,zip 等我们常见的压缩格式。然而，还有一种就是大家在学习数据结构最常见到的哈夫曼树的数据结构，以前还不知道他又什么用，其实他最大的用途就是用来做压缩，也是一些 rar,zip 压缩的祖先，称为哈弗曼压缩（什么你不知道谁是哈弗曼，也不知道哈弗曼压缩，不急等下介绍）。

   随着网络与多媒体技术的兴起，人们需要存储和传输的数据越来越多，数据量越来越大，以前带宽有限的传输网络和容量有限的存储介质难以满足用户的需求。

特别是声音、图像和视频等媒体在人们的日常生活和工作中的地位日益突出，这个问题越发显得严重和迫切。如今，数据压缩技术早已是多媒体领域中的关键技术之一。

一、什么是哈弗曼压缩

　　 Huffman( 哈夫曼 ) 算法在上世纪五十年代初提出来了，它是一种无损压缩方法，在压缩过程中不会丢失信息熵，而且可以证明Huffman 算法在无损压缩算法中是最优的。 Huffman 原理简单，实现起来也不困难，在现在的主流压缩软件得到了广泛的应用。对应用程序、重要资料等绝对不允许信息丢失的压缩场合， Huffman 算法是非常好的选择。

二、怎么实现哈弗曼压缩

   哈夫曼压缩是个无损的压缩算法，一般用来压缩文本和程序文件。哈夫曼压缩属于可变代码长度算法一族。意思是个体符号（例如，文本文件中的字符）用一个特定长度的位序列替代。因此，在文件中出现频率高的符号，使用短的位序列，而那些很少出现的符号，则用较长的位序列。

   故我们得了解几个概念：

  1 、二叉树 ： 在计算机科学中，二叉树是每个结点最多有两个子树的有序树。通常子树的根被称作 “ 左子树 ” （ left subtree ）和 “右子树 ” （ right subtree ）。


 

2 、哈夫曼编码 (Huffman Coding) ：是一种编码方式，哈夫曼编码是可变字长编码 (VLC) 的一种。 uffman 于 1952 年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长 度最短的码字，有时称之为最佳编码，一般就叫作 Huffman 编码。

 

三、哈夫曼编码生成步骤：

① 扫描要压缩的文件，对字符出现的频率进行计算。

② 把字符按出现的频率进行排序，组成一个队列。

③ 把出现频率最低（权值）的两个字符作为叶子节点，它们的权值之和为根节点组成一棵树。

④ 把上面叶子节点的两个字符从队列中移除，并把它们组成的根节点加入到队列。

⑤ 把队列重新进行排序。重复步骤 ③④⑤ 直到队列中只有一个节点为止。

⑥ 把这棵树上的根节点定义为 0 （可自行定义 0 或 1 ）左边为 0 ，右边为 1 。这样就可以得到每个叶子节点的哈夫曼编码了。


既如 (a) 、 (b) 、 (c) 、 (d) 几个图，就可以将离散型的数据转化为树型的了。

 

如果假设树的左边用0 表示右边用 1 表示，则每一个数可以用一个 01 串表示出来。


则可以得到对应的编码如下：

1-->110

2-->111

3-->10

4-->0

每一个01 串，既为每一个数字的哈弗曼编码。

为什么能压缩：

压缩的时候当我们遇到了文本中的1 、 2 、 3 、 4 几个字符的时候，我们不用原来的存储，而是转化为用它们的 01 串来存储不久是能减小了空间占用了吗。（什么 01 串不是比原来的字符还多了吗？怎么减少？）大家应该知道的，计算机中我们存储一个 int 型数据的时候一般式占用了 2^32-1 个 01 位，因为计算机中所有的数据都是最后转化为二进制位去存储的。所以，想想我们的编码不就是只含有 0 和 1 嘛，因此我们就直接将编码按照计算机的存储规则用位的方法写入进去就能实现压缩了。

比如：

1这个数字，用整数写进计算机硬盘去存储，占用了 2^32-1 个二进制位

  而如果用它的哈弗曼编码去存储，只有110 三个二进制位。

效果显而易见。

 

 

开始写程序:

 

开始些程序之前，必须想好自己的文件存储格式，和存储规则是什么

为了简便，我自定义存储的基本信息，格式如下：

 

 

SaveCode[i].n    int型   // 每一个字节的编码长度  i:0~256

B yte[]   byte数组型 // 每一个字节的编码 SaveCode[i].node 中 String 的 01 串转化而来。

 Byte[]  byte数组型 // 对文件中每一个 byte 的重新编码的哈夫曼编码写入。

 

有了定义好的格式我们的读写就非常的方便了，

创建步骤：

①读入文件中的所有字节：

Java代码 
  1. // 创建文件输入流  
  2.             java.io.FileInputStream fis = new java.io.FileInputStream(path);  
  3.             //读入所有的文件字节  
  4.             while(fis.available()>0){  
  5.                 int i=fis.read();  
  6.                 byteCount[i]++;  
  7.             }  
 

②构建哈夫曼树：

Java代码 
  1. /** 
  2.     * 使用优先队列构建哈弗曼树 
  3.     */  
  4.    public void createTree(){  
  5.    //优先队列  
  6.   PriorityQueue<hfmNode> nodeQueue = new PriorityQueue<hfmNode>();  
  7.     
  8.    //把所有的节点都加入到 队列里面去  
  9.     for (int i=0;i<256;i++){  
  10.         if(byteCount[i]!=0){  
  11.             hfmNode node = new hfmNode(i,byteCount[i]);  
  12.             nodeQueue.add(node);//加入节点  
  13.         }  
  14.     }  
  15.     //构建哈弗曼树  
  16.     while(nodeQueue.size()>1)  
  17.        {  
  18.         hfmNode min1 = nodeQueue.poll();//获取队列头  
  19.         hfmNode min2 = nodeQueue.poll();  
  20.           
  21.         hfmNode result = new hfmNode(0,min1.times+min2.times);  
  22.         result.lChild=min1;  
  23.         result.rChild=min2;  
  24.            nodeQueue.add(result);//加入合并节点  
  25.        }  
  26.     root=nodeQueue.peek(); //得到根节点  
  27. }  
 

这里我采用了优先队列的方法，因为优先队列比较符合哈夫曼的构造方法，形式上也非常的相似。

③取得每一个叶子节点的哈夫曼编码:

Java代码 
  1. /** 
  2.    * 获得叶子节点的哈弗曼编码  
  3.    * @param root 根节点 
  4.    * @param s 
  5.    */  
  6.   public void getMB(hfmNode root,String s){  
  7.       if ((root.lChild==null)&&(root.rChild==null)){  
  8.         Code hc=new Code();  
  9.         hc.node=s;  
  10.         hc.n=s.length();  
  11.         System.out.println("节点"+root.data+"编码"+hc.node);  
  12.         SaveCode[root.data]=hc;//保存字节  root.data 的编码 HC  
  13.        }  
  14.     if (root.lChild!=null){//左0 右 1  
  15.         getMB(root.lChild,s+'0');  
  16.     }  
  17.     if (root.rChild!=null){  
  18.         getMB(root.rChild,s+'1');  
  19.         }  
  20.     }  
 

如此一来我们的哈夫曼树就建好了。

下面就是按照我们之前定义的文件存储格式直接写进文件就可以了。

压缩文件的写入:

①  写出0~256 每一个字节对应编码的长度

Java代码 
  1. //写出每一个编码的长度  
  2.           for (int i=0;i<256;i++){  
  3.             fos.write(SaveCode[i].n);  
  4.           }    
 

② 写出每一个字节所对应的编码

这一步较为复杂，因为JAVA 中没有自己定义的二进制为写入，我们就不得不将每 8 个 01 String 转化为一个byte 再将 byte 写入。但是，问题又来了不是所有的 01String 都是 8 的整数倍，所以就又得在不是 8 整数倍的String 后面补上 0

Java代码 
  1. /////写入每一个字节所对应的 String编码  
  2.         int count=0;//记录中转的字符个数  
  3.         int i=0;//第i个字节  
  4.         String writes ="";  
  5.         String tranString="";//中转字符串  
  6.         String waiteString;//保存所转化的所有字符串  
  7.         while((i<256)||(count>=8)){  
  8.             //如果缓冲区的等待写入字符大于8  
  9.             if (count>=8){  
  10.                 waiteString="";//清空要转化的的码  
  11.                 for (int t=0;t<8;t++){  
  12.                     waiteString=waiteString+writes.charAt(t);     
  13.                  }  
  14.               
  15.                 //将writes前八位删掉  
  16.                 if (writes.length()>8){  
  17.                   tranString="";  
  18.                   for (int t=8;t<writes.length();t++){  
  19.                         tranString=tranString+writes.charAt(t);  
  20.                      }  
  21.                   writes="";  
  22.                   writes=tranString;  
  23.                   }else{  
  24.                       writes="";  
  25.                   }  
  26.                   
  27.                   count=count-8;//写出一个8位的字节  
  28.                   int intw=changeString(waiteString);//得到String转化为int  
  29.                   //写入文件  
  30.                   fos.write(intw);  
  31.             }else{  
  32.                 //得到地i个字节的编码信息，等待写入  
  33.                 count=count+SaveCode[i].n;  
  34.                 writes=writes+SaveCode[i].node;  
  35.                 i++;  
  36.             }  
  37.         }  
  38.         //把所有编码没有足够8的整数倍的String补0使得足够8的整数倍，再写入  
  39.         if (count>0){  
  40.             waiteString="";//清空要转化的的码  
  41.             for (int t=0;t<8;t++){  
  42.                 if (t<writes.length()){  
  43.                     waiteString=waiteString+writes.charAt(t);     
  44.                 }else{  
  45.                     waiteString=waiteString+'0';  
  46.                 }  
  47.             }  
  48.             fos.write(changeString(waiteString));//写入  
  49.             System.out.println("写入了->"+waiteString);  
  50.         }  
  51.   
  52.   
  53.    /** 
  54.     * 将一个八位的字符串转成一个整数 
  55.     * @param s 
  56.     * @return 
  57.     */  
  58.    public int changeString(String s){  
  59.     return ((int)s.charAt(0)-48)*128+((int)s.charAt(1)-48)*64+((int)s.charAt(2)-48)*32  
  60.             +((int)s.charAt(3)-48)*16+((int)s.charAt(4)-48)*8+((int)s.charAt(5)-48)*4  
  61.             +((int)s.charAt(6)-48)*2+((int)s.charAt(7)-48);  
  62. }  
 

③ 将源文件中的所有byte 转化为 01 哈夫曼编码，写入压缩文件

   这一步也比较复杂，原理同上一步，在SaveCode 中查找一个 byte 所对应的哈夫曼编码，不够 8 的整数倍的就不足，再写入。

   值得注意的事，最后一定要写一个byte 表示，补了多少个 0 方便解压缩时的删除 0

 

Java代码 
  1. //再次读入文件的信息，对应每一个字节写入编码  
  2.             count=0;  
  3.             writes ="";  
  4.             tranString="";  
  5.             int idata=fis.read();  
  6.             //文件没有读完的时候  
  7.             while ((fis.available()>0)||(count>=8)){  
  8.                 //如果缓冲区的等待写入字符大于8  
  9.                 if (count>=8){  
  10.                     waiteString="";//清空要转化的的码  
  11.                     for (int t=0;t<8;t++){  
  12.                         waiteString=waiteString+writes.charAt(t);     
  13.                      }  
  14.                      
  15.                    //将writes前八位删掉  
  16.                    if (writes.length()>8){  
  17.                      tranString="";  
  18.                      for (int t=8;t<writes.length();t++){  
  19.                         tranString=tranString+writes.charAt(t);  
  20.                        }  
  21.                       writes="";  
  22.                      writes=tranString;  
  23.                     }else{  
  24.                       writes="";  
  25.                     }  
  26.                      
  27.                      
  28.                   count=count-8;//写出一个8位的字节  
  29.                   int intw=changeString(waiteString);  
  30.                   fos.write(intw);//写到文件中区  
  31.                 }else{  
  32.                     //读入idata字节，对应编码写出信息  
  33.                     count=count+SaveCode[idata].n;  
  34.                     writes=writes+SaveCode[idata].node;  
  35.                     idata=fis.read();  
  36.                 }  
  37.             }  
  38.             count=count+SaveCode[idata].n;  
  39.             writes=writes+SaveCode[idata].node;  
  40.             //把count剩下的写入  
  41.              int endsint=0;  
  42.              if (count>0){  
  43.                 waiteString="";//清空要转化的的码  
  44.                 for (int t=0;t<8;t++){  
  45.                     if (t<writes.length()){  
  46.                     waiteString=waiteString+writes.charAt(t);     
  47.                 }else{  
  48.                     waiteString=waiteString+'0';  
  49.                     endsint++;  
  50.                     }  
  51.                 }  
  52.                 fos.write(changeString(waiteString));//写入所补的0  
 

如此一来，整个的压缩过程就完毕了。

 

解压缩过程：

    与压缩过程刚好是反着来进行的，知道的存储的方式我们就反着来读取看看。

①  读入所有字节所对应的编码长度：

 

Java代码 
  1. //读入文件中的每一个编码的长度  
  2.        for (int i=0;i<256;i++){  
  3.                Code hC=new Code();  
  4.                hC.n=fis.read();  
  5.                hC.node="";  
  6.            SaveCode[i]=hC;  
  7.        }  
 

② 读入每一个字节所对应的编码

Java代码 
  1. int i=0;  
  2.        int count=0;  
  3.        String coms="";  
  4.        //读SaveCode中0~256字节的的数据  
  5.        while (i<256){  
  6.                //当缓存区的编码长度比编码[i]的长度长的时候  
  7.                if (coms.length()>=SaveCode[i].n){  
  8.                       for (int t=0;t<SaveCode[i].n;t++){//SaveCode[i].node取得该编码  
  9.                           SaveCode[i].node=SaveCode[i].node+coms.charAt(t);  
  10.                       }  
  11.                         
  12.                       //把coms前这几位去掉  
  13.                       String coms2="";  
  14.                       for (int t=SaveCode[i].n;t<coms.length();t++){  
  15.                           coms2=coms2+coms.charAt(t);  
  16.                       }  
  17.                       coms="";  
  18.                       coms=coms2;//累计的下一个编码，继续的使用  
  19.                       i++;  
  20.                }else{  
  21.                     //如果已经没有写出的话，再度入一个byte转化为01 String  
  22.                     coms=coms+IntToString(fis.read());  
  23.                }  
  24.        }  
 

③ 读入文件的哈夫曼编码

得注意的事，前面我们又补0 的位，所以在我们读取的时候，记得把之前所补得东西，给删除掉就 OK 了。

Java代码 
  1. String rsrg;//存转换成的Sting  
  2.        String compString="";//存要比较的字符串  
  3.        //读入文件，写出文件  
  4.        while(fis.available()>1){  
  5.            if (search(compString)>=0){  
  6.                int cint=search(compString);  
  7.                fos.write(cint);  
  8.                //删掉前n个数据  
  9.                String compString2="";  
  10.                for (int t=SaveCode[cint].n;t<compString.length();t++){  
  11.                   compString2=compString2+compString.charAt(t);  
  12.                }  
  13.                compString="";  
  14.                compString=compString2;  
  15.                  
  16.            }else{//继续读入  
  17.                compString=compString+IntToString(fis.read());  
  18.            }  
  19.        }  
  20.          
  21.          
  22.        //处理最后一个字节  
  23.       int cint=fis.read();  
  24.       String compString2="";  
  25.       for (int t=0;t<compString.length()-cint;t++){  
  26.          compString2=compString2+compString.charAt(t);  
  27.       }  
  28.       compString=compString2;  
  29.         
  30.         
  31.        //删掉前n个数据  
  32.       while (compString.length()>0){  
  33.            int ccint=search(compString);  
  34.            fos.write(ccint);     
  35.            compString2="";  
  36.            for (int t=SaveCode[ccint].n;t<compString.length();t++){  
  37.             compString2=compString2+compString.charAt(t);  
  38.            }  
  39.            compString="";  
  40.            compString=compString2;  
  41.       }  
 
如此而来，一个简单的小压缩软件就实现了。

本次的文件读写比较复杂，之前些的时候遇到了很多的困难，参考了很多前辈的思路和代码，今天终于完成了，我~内牛满面
因为没有对其做任何的优化压缩的效率比较低，时间比较长，个位大侠不要见笑。

From: http://stchou.javaeye.com/blog/833232
posted on 2010-12-04 18:27 逛奔的蜗牛 阅读(3949) 评论(1)  编辑 收藏 引用 所属分类: Java

评论

# re: Java：自己动手写压缩软件，超详细解释（哈夫曼实现）[未登录] 2011-08-13 10:35 123
很多方法都木有写出来，看的晕死了···很桑心···  回复  更多评论
  


只有注册用户登录后才能发表评论。
网站导航: 博客园   IT新闻   BlogJava   博问   Chat2DB   管理