huffman编码

1.感谢：
Java读写二进制文件操作
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%左右。


作者：栗子酱油饼
链接：http://www.jianshu.com/p/a30953ab62a6
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。