1.感谢：
2.简介
这是学校课程的一个实验题目。我们先看看题目吧：
- 以字母(Character)为基础的压缩
- 文本解析：将cacm.all文件分解成一个个的字母
- 字频统计：统计每个字母出现的词频
- Huffman编码：根据Huffman编码的原理，对每个字母进行编码。给出一个编码字典。
- 文档压缩：根据Huffman编码，压缩文件。
- 文档还原：对压缩后的文档进行解压缩。
Huffman，首先要理解的是Huffman树，额这个参考一下：
huffman编码实现（详细实现）
然后，我们知道，压缩应该这样做：
-
1.读取文件，统计字符的频率/权重
-
2.根据字符的频率/权重生成一棵Huffman树，然后就得到了所谓的字符编码，0101，一寸二进制。
根据这个字符编码，我们就可以把文件中的每一个字符编成二进制！例如，源文件的字符“a"，其字典
是01，那么，以后文件中的a都用01代替！这样就构造了一个映射了，爽歪歪！ -
3.再读取源文件，根据字符字典，写入一个二进制文件中，完成！
看起来，还挺简单的，嗯，然后我们看看一些有坑的地方，和关键代码实现。
3.首先，我们来定义Huffman的结点类：
这里，还实现了一个
/**
* Created by Chestnut on 2016/11/6.
* 实现Comparable接口，使用优先队列
* 默认的优先队列是优先级最高的先push
* 而这里，我们需要：优先级（权重）
* 最小的先push.
*/
public class HufNode<A> implements Comparable<HufNode>{
private HufNode leftChild = null; //左孩子
private HufNode rightChild = null; //右孩子
private int weight = 0; //频率/权重
private A object = null; //结点存储的对象，如果没有，约定为空。
public HufNode(HufNode leftChild, HufNode rightChild, int weight, A object) {
this.leftChild = leftChild;
this.rightChild = rightChild;
this.weight = weight;
this.object = object;
}
public HufNode getLeftChild() {
return leftChild;
}
public void setLeftChild(HufNode leftChild) {
this.leftChild = leftChild;
}
public HufNode getRightChild() {
return rightChild;
}
public void setRightChild(HufNode rightChild) {
this.rightChild = rightChild;
}
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
public A getObject() {
return object;
}
public void setObject(A object) {
this.object = object;
}
@Override
public int compareTo(HufNode o) {
if (this.weight < o.weight)
return -1;
else if (this.weight > o.weight)
return 1;
else
return 0;
}
}
4 .文件的字符统计
这个实现起来，还挺简单。
注意FileReader，其实用来读取文件内容，
当读到文件尾的时候，fileReader.read()返回-1.
/**
* 根据文件路径返回 Huffman 节点集合
* @param filePath
* @return
*/
public static List<HufNode> getHuffNodes(String filePath) {
List<Character> characters = null;
List<HufNode> hufNodes = null;
try(
FileReader fileReader = new FileReader(filePath)
){
hufNodes = new ArrayList<>();
characters = new ArrayList<>();
int ch ;
while ((ch = fileReader.read())!=-1) {
char temp = (char) ch;
if (!characters.contains(temp)) {
characters.add(temp);
HufNode<Character> hufNode = new HufNode<>(null,null,1,temp);
hufNodes.add(hufNode);
}
else {
int index = characters.indexOf(temp);
int weight = hufNodes.get(index).getWeight();
hufNodes.get(index).setWeight(++weight);
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
System.out.println("FileNotFoundException:"+e.getMessage());
} catch (IOException e) {
e.printStackTrace();
System.out.println("IOException:"+e.getMessage());
}
return hufNodes;
}
这里要非常注意，FileReader的用法。
例如，当向文件写入：int -1，那么，实际上，
用二进制看文件，会发现：FF FF FF FF
嗯，很对，int型是32位，转成16进制就是8位了，而，-1的16进制就是：FF FF FF FF。
使用fileReader.read()的话，按照Ascii码返回！
也就是说，这里去read的话，不会返回-1，返回的是65535！
5.然后就是建立Huffman树了...
/**
* 构造Huffman树
* 约定：左子树 <= 右子树
* @param hufNodes 传入乱序的所有原始数据
* @return Huffman的头
*/
public static HufNode buildHuffTree(List<HufNode> hufNodes) {
PriorityQueue<HufNode> priorities = new PriorityQueue<>();
priorities.addAll(hufNodes);
HufNode New;
for (int i = 0; i < hufNodes.size() - 1; i++) {
HufNode a = priorities.poll();
HufNode b = priorities.poll();
New = new HufNode(a,b,a.getWeight()+b.getWeight(),null);
if (priorities.isEmpty())
return New;
priorities.add(New);
}
return null;
}
这里传入的是乱序的原始结点。这里就通过一个优先队列去排序。
优先队列：java中原本的实现，是按照插入队列中的数据中的权值，由小到大poll出来。
这里是不是有点符合我们的Huffman树的构造了，把权重最大的放在离root节点最近。
所以，这里的HuffmanNode类就实现了一个优先队列的排序接口。
6 .得到字符字典/字符编码
/**
* 得到编码字典
* @param rootNode 根节点
* @return 编码
*/
public static Map<Character, String> getLetterCode(HufNode rootNode) {
Map<Character, String> letterCode = new HashMap<Character, String>();
getLetterCode(rootNode, "", letterCode);
return letterCode;
}
/**
* 先序遍历哈夫曼树,获得所有字符编码对。
* @param rooNode 哈夫曼树根结点
* @param suffix 编码前缀，也就是编码这个字符时，之前路径上的所有编码
* @param letterCode 用于保存字符编码结果
*/
private static void getLetterCode(HufNode rooNode, String suffix, Map<Character, String> letterCode) {
if (rooNode != null) {
if (rooNode.getLeftChild() == null && rooNode.getRightChild() == null) {
Character character = (Character) rooNode.getObject();
letterCode.put(character, suffix);
}
getLetterCode(rooNode.getLeftChild(), suffix + "0", letterCode);
getLetterCode(rooNode.getRightChild(), suffix + "1", letterCode);
}
}
核心思想就是，先序遍历！很熟悉呐，套路的递归。
7 .编码压缩
根据编码去重新读取源文件的每一个字符，再存入新的文件，以0101的形式，也就是二进制。
这里，我们要考虑几个问题：
- (1) .文件的后缀
- (2) .文件的字符字典
- (3) .文件的末尾
java中的二进制读写，是一定要用：DataInputStream && DataOutputStream
这里，我是这样约定的，
先存文件的后缀，然后是字符字典，最后是正文。
正文中，0101流按照由（int）高位到地址存放。
而且，为了标记是当前的内容是文件的后缀，还是字符字典，还是文件末尾，我把int的最高位
也就是符号位不作为正文的使用。
约定如下：
/**
* Created by Chestnut on 2016/11/6.
*
* 在这里定义编码的格式如下：
*
* (这里，约定使用int的31位，最高位为0)
* (最高位为1，即符号标志位为1的，约定为一些敏感字段的头和尾)
*
* [int:-1] 文件头（包含一些文件信息，例如后缀等等）
* [int:-10] 文件后缀(一个int)
* [int:一个int]
* unknown:0（没约定）
* txt : 1
* jpg : 2
* ...（需要约定）
* [int:-1]
*
* [int:-2] 字符字典：
* [int:] （这个为字符！），为16进制！应该解析为字符。
* [int:]...（字符的频率/权重：）
* ...
* [int:-2]
*
* [int:-3] 编码区
* [int:] n个int,为正数，最高位为0。
* ...
* ...
* ...
* [int:-301] 说明下一个是最后一个int的开始。
* [int:] 说明剩下的bit数
* [int:]...数据
* [int:-3]
*
*
*/
这里的字符字典我使用的是字符的权重去存储，
其实这也可以压缩一下，存储0101.
然后，根据这个约定，我们就可以去压缩了。
在这之前，放出几个必要的函数：
/**
* 从int获取第index位bit(0/1)
* @param a int
* @param index 位置，1-32
* @return 0/1 char
*/
public static char getBitFromInt(int a, int index) {
if (index<0 || index>32)
return '0';
return (a>>index-1 & 0x00000001) == 1 ? '1' : '0';
}
/**
* 把bit写入到int里面
* @param a int
* @param bit 位，只能是'1' or '0'
* @param index 位置，1-32
*/
public static int writeBitToInt(int a,char bit,int index) {
if (bit=='0' || index<0 || index>32)
return a;
return 1<<index-1 | a;
}
/**
* 根据letterCode和字符取得编码字典
* @param letterCode
* @param c
* @return
*/
public static String getEncodeFromOneChar(Map<Character,String> letterCode, char c) {
Set<Character> set = letterCode.keySet();
if (set.contains(c)) {
return letterCode.get(c);
}
return "";
}
这几个都是读写int型数据的bit位。（为啥要这么蛋疼？一位一位bit写不可以吗？不可以，java不支持...）
压缩的代码：
/**
* 编码
* @param src 源文件地址
* @param encode 编码到哪个文件
* @param letterCode 字符字典
* @param hufNodes 最原始的带有字符频率的Huffman结点
* @return 是否成功
*/
public static boolean encode(String src, String encode, Map<Character,String> letterCode, List<HufNode> hufNodes) {
//取得后缀名
String suffix = src.substring(src.lastIndexOf(".")+1);
int suffixCode = 0;
switch (suffix) {
case "txt":
suffixCode = 1;
break;
case "jpg":
suffixCode = 2;
break;
}
try(
DataOutputStream writer = new DataOutputStream(new FileOutputStream(encode));
FileReader reader = new FileReader(src)
) {
// [int:-1] 文件头（包含一些文件信息，例如后缀等等）
// [int:-10] 文件后缀(一个int)
// [int:一个int]
// unknown:0（没约定）
// txt : 1
// jpg : 2
// ...（需要约定）
// [int:-1]
writer.writeInt(-1);
writer.writeInt(-10);
writer.writeInt(suffixCode);
writer.writeInt(-1);
// [int:-2] 字符字典：
// [int:] （这个为字符！），为16进制！应该解析为字符。
// [int:]...（字符的频率/权重：）
// ...
// [int:-2]
writer.writeInt(-2);
for (int i = 0; i < hufNodes.size(); i++) {
writer.writeInt((Character)hufNodes.get(i).getObject());
writer.writeInt(hufNodes.get(i).getWeight());
}
writer.writeInt(-2);
// [int:-3] 编码区
// [int:] n个int,为正数，最高位为0。
// ...
// ...
// ...
// [int:-301] 说明下一个是最后一个int的开始。
// [int:] 说明剩下的bit数
// [int:]...数据
// [int:-3]
writer.writeInt(-3);
int ch ;
ArrayBlockingQueue<Character> arrayBlockingQueue = new ArrayBlockingQueue<>(100);
String xxx ;
while ((ch = reader.read())!=-1) {
char ii = (char) ch;
xxx = getEncodeFromOneChar(letterCode, ii);
for (int i = 0; i < xxx.length(); i++) {
arrayBlockingQueue.add(xxx.charAt(i));
if (arrayBlockingQueue.size()>=31) {
int pp = 0;
for (int j = 0; j < 31; j++) {
pp = writeBitToInt(pp,arrayBlockingQueue.poll(),31-j);
}
pp = writeBitToInt(pp,'0',32);
writer.writeInt(pp);
}
}
}
if (!arrayBlockingQueue.isEmpty()) {
writer.writeInt(-301);
writer.writeInt(arrayBlockingQueue.size());
int pp = 0;
int length = arrayBlockingQueue.size();
for (int i = 0; i < length; i++) {
pp = writeBitToInt(pp,arrayBlockingQueue.poll(),length-i);
}
writer.writeInt(pp);
} else {
writer.writeInt(-301);
writer.writeInt(0);
}
writer.writeInt(-3);
return true;
} catch (IOException e) {
File file = new File(encode);
if (file.exists())
file.delete();
e.printStackTrace();
return false;
}
}
仔细看看注释应该可以懂，不懂再问我哈。
8 .解码解压
清楚了上面的压缩编码，解码就很容易：
/**
* 解码
* @param src 待解码文件
* @param decodeFilePath 解压的路径，注意，其是一个路径而不是一个文件。
* @return 是否成功
*/
public static boolean decode(String src, String decodeFilePath) {
File file = new File(src);
if (!file.exists()) return false;
try (
DataInputStream in = new DataInputStream(
new BufferedInputStream(
new FileInputStream(src)))
){
int temp;
//[-1]读取文件头
temp = in.readInt();
if (temp!=-1) return false;
while ((temp = in.readInt())!=-1) {
//读取自定义的信息
switch (temp) {
case -10://后缀
String suffix;
switch (in.readInt()) {
case 1:
suffix = ".txt";
break;
case 2:
suffix = ".jpg";
break;
default:
suffix = ".unknown";
break;
}
decodeFilePath += "temp" + suffix;
break;
}
}
//[-2]读取字符频率/权重
temp = in.readInt();
if (temp!=-2) return false;
List<HufNode> hufNodes = new ArrayList<>();
while ((temp = in.readInt())!=-2) {
//读取字符
char a = (char) temp;
int weight = in.readInt();
hufNodes.add(new HufNode<>(null,null,weight,a));
}
//建立Huffman树
HufNode<Character> root = buildHuffTree(hufNodes);
try(
DataOutputStream writer = new DataOutputStream(new FileOutputStream(decodeFilePath))
) {
//[-3]读取编码 & 写入文件
HufNode<Character> point = root;
temp = in.readInt();
if (temp!=-3) return false;
while ((temp = in.readInt())!=-3) {
switch (temp) {
case -301://到最后一个int
int lastIntLength = in.readInt();
temp = in.readInt();
//读取 & 写入
for (int i = 0; i < lastIntLength; i++) {
point = getBitFromInt(temp,lastIntLength-i) == '1' ? point.getRightChild() : point.getLeftChild();
if (point.getObject()!=null) {
writer.write(point.getObject());
point = root;
}
}
break;
default:
//读取 & 写入
for (int i = 0; i < 31; i++) {
point = getBitFromInt(temp,31-i) == '1' ? point.getRightChild() : point.getLeftChild();
if (point.getObject()!=null) {
writer.write(point.getObject());
point = root;
}
}
break;
}
}
}catch (Exception e) {
e.printStackTrace();
return false;
}
}catch (Exception e) {
e.printStackTrace();
return false;
}
return true;
}
9 .组合的一个工具类：HuffmanUtils
package Lab5;
import java.io.*;
import java.util.*;
import java.util.concurrent.ArrayBlockingQueue;
/**
* Created by Chestnut on 2016/11/6.
*
* 在这里定义编码的格式如下：
*
* (这里，约定使用int的31位，最高位为0)
* (最高位为1，即符号标志位为1的，约定为一些敏感字段的头和尾)
*
* [int:-1] 文件头（包含一些文件信息，例如后缀等等）
* [int:-10] 文件后缀(一个int)
* [int:一个int]
* unknown:0（没约定）
* txt : 1
* jpg : 2
* ...（需要约定）
* [int:-1]
*
* [int:-2] 字符字典：
* [int:] （这个为字符！），为16进制！应该解析为字符。
* [int:]...（字符的频率/权重：）
* ...
* [int:-2]
*
* [int:-3] 编码区
* [int:] n个int,为正数，最高位为0。
* ...
* ...
* ...
* [int:-301] 说明下一个是最后一个int的开始。
* [int:] 说明剩下的bit数
* [int:]...数据
* [int:-3]
*
*
*/
public class HuffmanUtils {
/**
* 从int获取第index位bit(0/1)
* @param a int
* @param index 位置，1-32
* @return 0/1 char
*/
public static char getBitFromInt(int a, int index) {
if (index<0 || index>32)
return '0';
return (a>>index-1 & 0x00000001) == 1 ? '1' : '0';
}
/**
* 把bit写入到int里面
* @param a int
* @param bit 位，只能是'1' or '0'
* @param index 位置，1-32
*/
public static int writeBitToInt(int a,char bit,int index) {
if (bit=='0' || index<0 || index>32)
return a;
return 1<<index-1 | a;
}
/**
* 根据letterCode和字符取得编码字典
* @param letterCode
* @param c
* @return
*/
public static String getEncodeFromOneChar(Map<Character,String> letterCode, char c) {
Set<Character> set = letterCode.keySet();
if (set.contains(c)) {
return letterCode.get(c);
}
return "";
}
/**
* 得到编码字典
* @param rootNode 根节点
* @return 编码
*/
public static Map<Character, String> getLetterCode(HufNode rootNode) {
Map<Character, String> letterCode = new HashMap<Character, String>();
getLetterCode(rootNode, "", letterCode);
return letterCode;
}
/**
* 先序遍历哈夫曼树,获得所有字符编码对。
* @param rooNode 哈夫曼树根结点
* @param suffix 编码前缀，也就是编码这个字符时，之前路径上的所有编码
* @param letterCode 用于保存字符编码结果
*/
private static void getLetterCode(HufNode rooNode, String suffix, Map<Character, String> letterCode) {
if (rooNode != null) {
if (rooNode.getLeftChild() == null && rooNode.getRightChild() == null) {
Character character = (Character) rooNode.getObject();
letterCode.put(character, suffix);
}
getLetterCode(rooNode.getLeftChild(), suffix + "0", letterCode);
getLetterCode(rooNode.getRightChild(), suffix + "1", letterCode);
}
}
/**
* 构造Huffman树
* 约定：左子树 <= 右子树
* @param hufNodes 传入乱序的所有原始数据
* @return Huffman的头
*/
public static HufNode buildHuffTree(List<HufNode> hufNodes) {
PriorityQueue<HufNode> priorities = new PriorityQueue<>();
priorities.addAll(hufNodes);
HufNode New;
for (int i = 0; i < hufNodes.size() - 1; i++) {
HufNode a = priorities.poll();
HufNode b = priorities.poll();
New = new HufNode(a,b,a.getWeight()+b.getWeight(),null);
if (priorities.isEmpty())
return New;
priorities.add(New);
}
return null;
}
/**
* 编码
* @param src 源文件地址
* @param encode 编码到哪个文件
* @param letterCode 字符字典
* @param hufNodes 最原始的带有字符频率的Huffman结点
* @return 是否成功
*/
public static boolean encode(String src, String encode, Map<Character,String> letterCode, List<HufNode> hufNodes) {
//取得后缀名
String suffix = src.substring(src.lastIndexOf(".")+1);
int suffixCode = 0;
switch (suffix) {
case "txt":
suffixCode = 1;
break;
case "jpg":
suffixCode = 2;
break;
}
try(
DataOutputStream writer = new DataOutputStream(new FileOutputStream(encode));
FileReader reader = new FileReader(src)
) {
// [int:-1] 文件头（包含一些文件信息，例如后缀等等）
// [int:-10] 文件后缀(一个int)
// [int:一个int]
// unknown:0（没约定）
// txt : 1
// jpg : 2
// ...（需要约定）
// [int:-1]
writer.writeInt(-1);
writer.writeInt(-10);
writer.writeInt(suffixCode);
writer.writeInt(-1);
// [int:-2] 字符字典：
// [int:] （这个为字符！），为16进制！应该解析为字符。
// [int:]...（字符的频率/权重：）
// ...
// [int:-2]
writer.writeInt(-2);
for (int i = 0; i < hufNodes.size(); i++) {
writer.writeInt((Character)hufNodes.get(i).getObject());
writer.writeInt(hufNodes.get(i).getWeight());
}
writer.writeInt(-2);
// [int:-3] 编码区
// [int:] n个int,为正数，最高位为0。
// ...
// ...
// ...
// [int:-301] 说明下一个是最后一个int的开始。
// [int:] 说明剩下的bit数
// [int:]...数据
// [int:-3]
writer.writeInt(-3);
int ch ;
ArrayBlockingQueue<Character> arrayBlockingQueue = new ArrayBlockingQueue<>(100);
String xxx ;
while ((ch = reader.read())!=-1) {
char ii = (char) ch;
xxx = getEncodeFromOneChar(letterCode, ii);
for (int i = 0; i < xxx.length(); i++) {
arrayBlockingQueue.add(xxx.charAt(i));
if (arrayBlockingQueue.size()>=31) {
int pp = 0;
for (int j = 0; j < 31; j++) {
pp = writeBitToInt(pp,arrayBlockingQueue.poll(),31-j);
}
pp = writeBitToInt(pp,'0',32);
writer.writeInt(pp);
}
}
}
if (!arrayBlockingQueue.isEmpty()) {
writer.writeInt(-301);
writer.writeInt(arrayBlockingQueue.size());
int pp = 0;
int length = arrayBlockingQueue.size();
for (int i = 0; i < length; i++) {
pp = writeBitToInt(pp,arrayBlockingQueue.poll(),length-i);
}
writer.writeInt(pp);
} else {
writer.writeInt(-301);
writer.writeInt(0);
}
writer.writeInt(-3);
return true;
} catch (IOException e) {
File file = new File(encode);
if (file.exists())
file.delete();
e.printStackTrace();
return false;
}
}
/**
* 解码
* @param src 待解码文件
* @param decodeFilePath 解压的路径，注意，其是一个路径而不是一个文件。
* @return 是否成功
*/
public static boolean decode(String src, String decodeFilePath) {
File file = new File(src);
if (!file.exists()) return false;
try (
DataInputStream in = new DataInputStream(
new BufferedInputStream(
new FileInputStream(src)))
){
int temp;
//[-1]读取文件头
temp = in.readInt();
if (temp!=-1) return false;
while ((temp = in.readInt())!=-1) {
//读取自定义的信息
switch (temp) {
case -10://后缀
String suffix;
switch (in.readInt()) {
case 1:
suffix = ".txt";
break;
case 2:
suffix = ".jpg";
break;
default:
suffix = ".unknown";
break;
}
decodeFilePath += "temp" + suffix;
break;
}
}
//[-2]读取字符频率/权重
temp = in.readInt();
if (temp!=-2) return false;
List<HufNode> hufNodes = new ArrayList<>();
while ((temp = in.readInt())!=-2) {
//读取字符
char a = (char) temp;
int weight = in.readInt();
hufNodes.add(new HufNode<>(null,null,weight,a));
}
//建立Huffman树
HufNode<Character> root = buildHuffTree(hufNodes);
try(
DataOutputStream writer = new DataOutputStream(new FileOutputStream(decodeFilePath))
) {
//[-3]读取编码 & 写入文件
HufNode<Character> point = root;
temp = in.readInt();
if (temp!=-3) return false;
while ((temp = in.readInt())!=-3) {
switch (temp) {
case -301://到最后一个int
int lastIntLength = in.readInt();
temp = in.readInt();
//读取 & 写入
for (int i = 0; i < lastIntLength; i++) {
point = getBitFromInt(temp,lastIntLength-i) == '1' ? point.getRightChild() : point.getLeftChild();
if (point.getObject()!=null) {
writer.write(point.getObject());
point = root;
}
}
break;
default:
//读取 & 写入
for (int i = 0; i < 31; i++) {
point = getBitFromInt(temp,31-i) == '1' ? point.getRightChild() : point.getLeftChild();
if (point.getObject()!=null) {
writer.write(point.getObject());
point = root;
}
}
break;
}
}
}catch (Exception e) {
e.printStackTrace();
return false;
}
}catch (Exception e) {
e.printStackTrace();
return false;
}
return true;
}
/**
* 根据文件路径返回 Huffman 节点集合
* @param filePath
* @return
*/
public static List<HufNode> getHuffNodes(String filePath) {
List<Character> characters = null;
List<HufNode> hufNodes = null;
try(
FileReader fileReader = new FileReader(filePath)
){
hufNodes = new ArrayList<>();
characters = new ArrayList<>();
int ch ;
while ((ch = fileReader.read())!=-1) {
char temp = (char) ch;
if (!characters.contains(temp)) {
characters.add(temp);
HufNode<Character> hufNode = new HufNode<>(null,null,1,temp);
hufNodes.add(hufNode);
}
else {
int index = characters.indexOf(temp);
int weight = hufNodes.get(index).getWeight();
hufNodes.get(index).setWeight(++weight);
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
System.out.println("FileNotFoundException:"+e.getMessage());
} catch (IOException e) {
e.printStackTrace();
System.out.println("IOException:"+e.getMessage());
}
return hufNodes;
}
}
工具类的使用：
public static void main(String[] args) {
//从给出的文件得到字符的频率：建立起Huffman节点集合。
List<HufNode> hufNodes = HuffmanUtils.getHuffNodes(FilePath);
//建立Huffman树
HufNode<Character> root = HuffmanUtils.buildHuffTree(hufNodes);
//得到编码字典
Map<Character,String> letterCode = HuffmanUtils.getLetterCode(root);
//编码压缩：
if (HuffmanUtils.encode(FilePath,FilePathEncode,letterCode,hufNodes)) {
if (!HuffmanUtils.decode(FilePathEncode,decodeFilePath))
System.out.println("解码失败！");
}
else
System.out.println("压缩失败！");
}
10 .总结
整个做下来，坑啊，自己知道，我的坑也不一定是你的坑，哈哈，所以，慢慢弄咯。
最后的压缩率（压缩的文件大小/压缩前的大小）为68%左右。
网友评论