用Java实现【哈夫曼树】的数据压缩

关于哈夫曼树入门请看上节 《用Java实现【哈夫曼树】》

本文代码文件哈夫曼树完整代码

哈夫曼树基本代码

//1. 将赫夫曼编码表存放在 Map<Byte,String> 形式
    static Map<Byte, String> huffmanCodes = new HashMap<>();
    //2. 在生成赫夫曼编码表示，需要去拼接路径, 定义一个StringBuilder 存储某个叶子结点的路径
    static StringBuilder stringBuilder = new StringBuilder();

    private static Map<Byte, String> getCodes(Node root) {
        if (root == null) {
            return null;
        }
        getCodes(root.leftNode, "0", stringBuilder);
        getCodes(root.rightNode, "1", stringBuilder);
        return huffmanCodes;
    }

    /**
     * 将传入的node结点的所有叶子结点的赫夫曼编码放入huffmanCodes
     *
     * @param node          传入结点
     * @param code          左子节点是0，右子节点是1
     * @param stringBuilder
     */
    private static void getCodes(Node node, String code, StringBuilder stringBuilder) {
        StringBuilder stringBuilder2 = new StringBuilder(stringBuilder);
        stringBuilder2.append(code);
        /*node == null 时 不处理*/
        if (node != null) {
            /* 判断当前结点时不是叶子结点,node.data==null 时 是非叶子节点*/
            if (node.data == null) {
                //向左递归
                getCodes(node.leftNode, "0", stringBuilder2);
                //向右递归
                getCodes(node.rightNode, "1", stringBuilder2);
            } else {
                huffmanCodes.put(node.data, stringBuilder2.toString());
            }

        }

    }

    /**
     * 将数组转化为结点集合
     *
     * @param bytes 待压缩数组
     * @return 结点集合
     */
    private static List<Node> getNodes(byte[] bytes) {
        /** 1.创建一个ArrayList */
        ArrayList<Node> nodes = new ArrayList<Node>();
        /** 2.遍历bytes,统计每一个byte出现的次数 */
        Map<Byte, Integer> counts = new HashMap<>();
        for (byte b : bytes) {
            Integer count = counts.get(b);
            if (count == null) {
                counts.put(b, 1);
            } else {
                counts.put(b, count + 1);
            }
        }
        /** 3.把每一个键值对转成一个Node 对象并加入到nodes集合 */
        for (Map.Entry<Byte, Integer> entry : counts.entrySet()) {
            nodes.add(new Node(entry.getKey(), entry.getValue()));
        }
        /** 4.将转换好的结点集合返回 */
        return nodes;
    }

    /**
     * 根据结点集合创建对应的赫夫曼树
     *
     * @param nodes 结点集合
     * @return 赫夫曼树
     */
    private static Node createHuffmanTree(List<Node> nodes) {
        while (nodes.size() > 1) {
            /** 将结点集合从小到大排序*/
            Collections.sort(nodes);
            /** 取出第一颗最小的二叉树*/
            Node leftNode = nodes.get(0);
            /** 取出第二颗最小的二叉树*/
            Node rightNode = nodes.get(1);
            /** 创建一颗新的二叉树,根节点只有权值*/
            Node parent = new Node(null, leftNode.weight + rightNode.weight);
            parent.leftNode = leftNode;
            parent.rightNode = rightNode;

            /** 将已经处理好的结点进行删除 */
            nodes.remove(leftNode);
            nodes.remove(rightNode);
            /* 将新二叉树加入nodes */
            nodes.add(parent);
        }
        /* 最终剩余的一个结点就是赫夫曼数的根节点，将其返回*/
        return nodes.get(0);
    }

    /**
     * 前序遍历结点
     * @param root
     */
    private static void preOrder(Node root) {
        if (root != null) {
            root.preOrder();
        } else {
            System.out.println("root is empty! ");
        }
    }
}

/**
 * 创建Node结点，存放数据和权值
 */
class Node implements Comparable<Node> {
    // 存放数据(字符)
    Byte data;
    // 权值
    int weight;
    //左子结点
    Node leftNode;
    //右子结点
    Node rightNode;

    /**
     * 前序遍历结点
     */
    public void preOrder() {
        System.out.println(this);
        if (this.leftNode != null) {
            this.leftNode.preOrder();
        }
        if (this.rightNode != null) {
            this.rightNode.preOrder();
        }
    }

    public Node(Byte data, int weight) {
        this.data = data;
        this.weight = weight;
    }

    @Override
    public int compareTo(Node o) {
        return this.weight - o.weight;
    }

    @Override
    public String toString() {
        return "Node{data=" + data + ", weight=" + weight + '}';
    }

一、数据压缩

    /**
     * 封装数据压缩
     *
     * @param bytes 原始字符串对应的字节数组
     * @return 压缩后的数组
     */
    private static byte[] huffmanZip(byte[] bytes) {
        // 1.将数据转换成节点集合
        List<Node> nodes = getNodes(bytes);
        // 2.创建为赫夫曼树
        Node root = createHuffmanTree(nodes);
//        root.preOrder();
        // 3.生成赫夫曼编码
        Map<Byte, String> huffmanCodes = getCodes(root);
        byte[] huffmanCodeBytes = zip(bytes, huffmanCodes);
        return huffmanCodeBytes;
    }

 	/**
     * 数据压缩
     *
     * @param bytes        这时原始的字符串对应的 byte[]
     * @param huffmanCodes 生成的赫夫曼编码map
     * @return 返回赫夫曼编码处理后的 byte[]
     */
    private static byte[] zip(byte[] bytes, Map<Byte, String> huffmanCodes) {
        /*1. 利用huffmanCodes 将bytes 转成 赫夫曼编码对应的字符串*/
        StringBuilder stringBuilder = new StringBuilder();
        //遍历bytes数组
        for (byte b : bytes) {
            stringBuilder.append(huffmanCodes.get(b));
        }
        //长度
        int len = (stringBuilder.length() + 7) / 8;
        // 创建 存储压缩后的byte数组
        byte[] huffmanCodeBytes = new byte[len];
        //记录 huffmanCodeBytes 下标
        int index = 0;
        for (int i = 0; i < stringBuilder.length(); i += 8) {
            String strByte;
            if (i + 8 > stringBuilder.length()) {
                // 不足8位则直接截取到最后
                strByte = stringBuilder.substring(i);
            } else {
                strByte = stringBuilder.substring(i, i + 8);
            }
            //字符串转二进制，将strByte转为byte放入压缩后的数组中
            huffmanCodeBytes[index] = (byte) Integer.parseInt(strByte, 2);
            index++;
        }
        return huffmanCodeBytes;
    }
		

二、数据解压

public static byte[] decode(Map<Byte, String> huffmanCodes, byte[] huffmanBytes) {
        //先得到huffmanBytes对应的 二进制的字符串
        StringBuilder stringBuilder = new StringBuilder();
        //将byte数组转换成二进制的字符串
        for (int i = 0; i < huffmanBytes.length; i++) {
            byte b = huffmanBytes[i];
            //判断是不是最后一个字节，最后一个字节无需补码
            boolean flag = (i == huffmanBytes.length - 1);
            stringBuilder.append(byteToBitString(!flag, b));
        }
        //把字符串安装指定的赫夫曼编码进行解码
        //把赫夫曼编码表进行调换,因为反向查询
        Map<String, Byte> map = new HashMap<>();
        for (Map.Entry<Byte, String> entry : huffmanCodes.entrySet()) {
            map.put(entry.getValue(), entry.getKey());
        }
        // 创建要给集合,存放byte
        List<Byte> list = new ArrayList<>();
        // i 可以理解为索引,扫描stringBuilder
        for (int i = 0; i < stringBuilder.length(); ) {
            int count = 1;
            boolean flag = true;
            Byte b = null;

            while (flag) {
                String key = stringBuilder.substring(i, i + count);
                b = map.get(key);
                //b == null 说明没有匹配到
                if (b == null) {
                    count++;
                } else {
                    flag = false;
                }
            }
            list.add(b);
            //i直接移动到count
            i += count;
        }
        //for循环结束后,我们list中就存放了所有的字符
        //把list 中的数据放入byte[] 并返回
        byte b[] = new byte[list.size()];
        for (int i = 0; i < b.length; i++) {
            b[i] = list.get(i);
        }
        return b;
    }


    /**
     * 将一个byte 转成一个二进制的字符串
     *
     * @param flag 标志是否需要补高位,true表示需要
     * @param b    传入的byte
     * @return 该byte 对应的二进制的字符串（补码）
     */
    private static String byteToBitString(boolean flag, byte b) {
        //使用变量保存b
        //将byte转为int
        int temp = b;
        if (flag) {
            //按位或 256  1 0000 0000  | 0000 0001 => 1 0000 0001
            temp |= 256;
        }
        //返回的是temp对应的二进制的补码
        String str = Integer.toBinaryString(temp);
        if (flag || temp < 0) {
            return str.substring(str.length() - 8);
        } else {
            return str;
        }
    }

三、文件压缩

/**
     * 文件压缩
     *
     * @param srcFile 输入文件路径
     * @param dstFile 输出文件路径
     */
    public static void zipFile(String srcFile, String dstFile) {
        //创建输入输出流
        FileInputStream is = null;
        OutputStream os = null;
        ObjectOutputStream oos = null;

        try {
            is = new FileInputStream(srcFile);
            //创建一个和源文件大小一样的byte[]
            byte[] b = new byte[is.available()];
            //读取文件
            is.read(b);
            //对源文件进行压缩
            byte[] huffmanBytes = huffmanZip(b);
            //创建文件输出流，存放压缩文件
            os = new FileOutputStream(dstFile);
            //创建和文件输出流关联的ObjectOutputStream
            oos = new ObjectOutputStream(os);
            //把 哈夫曼编码后的 字节数组和赫夫曼编码 写入压缩文件
            oos.writeObject(huffmanBytes);
            oos.writeObject(huffmanCodes);

            is.close();
            oos.close();
            os.close();

        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

四、文件解压

/**
     * 文件解压
     *
     * @param srcFile 待解压文件路径
     * @param dstFile 解压后的文件路径
     */
    public static void unZipFile(String srcFile, String dstFile) {
        //创建输入输出流
        FileInputStream is = null;
        OutputStream os = null;
        ObjectInputStream ois = null;
        try {
            //创建文件输入流
            is = new FileInputStream(srcFile);
            //创建一个和is关联的对象输入流
            ois = new ObjectInputStream(is);
            //读取byte数组
            byte[] huffmanBytes = (byte[]) ois.readObject();
            //读取哈夫曼编码表
            Map<Byte, String> huffmanCodes = (Map<Byte, String>) ois.readObject();

            //解码
            byte[] bytes = decode(huffmanCodes, huffmanBytes);
            //将bytes数组写入到目标文件
            os = new FileOutputStream(dstFile);
            //写数据到dstFile文件
            os.write(bytes);

            is.close();
            ois.close();
            os.close();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }

    }