思路分析

代码实现

package com.atguigu.huffmancode;import com.sun.org.glassfish.external.statistics.CountStatistic;
import com.sun.org.glassfish.external.statistics.StringStatistic;import javax.xml.bind.SchemaOutputResolver;
import java.io.*;
import java.security.AlgorithmConstraints;
import java.util.*;/*** @创建人 wdl* @创建时间 2021/3/27* @描述*/
public class HuffmanCode {public static void main(String[] args) {//测试压缩文件
//        String srcFile="C://Users//王东梁//Desktop//88888888.png";
//        String dstFile="C://Users//王东梁//Desktop//dst.zip";
//        zipFile(srcFile,dstFile);
//        System.out.println("压缩文件成功");//测试解压文件String zipFile="C://Users//王东梁//Desktop//dst.zip";String dstFile="C://Users//王东梁//Desktop//99999999.png";unZipFile(zipFile,dstFile);System.out.println("解压文件成功");//        String content="i like like like java do you like a java";
//        byte[] contentBytes = content.getBytes();
//        System.out.println(contentBytes.length);//40
//
//        byte[] huffmanCodesBytes = huffmanZip(contentBytes);
//        System.out.println("压缩后的结果"+Arrays.toString(huffmanCodesBytes)+huffmanCodesBytes.length);
//
//        //测试一把byteToBitString方法
//        byte[] sourceBytes = decode(huffmanCodes, huffmanCodesBytes);
//        System.out.println(new String(sourceBytes));//
//        List<Node> nodes = getNodes(contentBytes);
//        System.out.println(nodes);
//
//        //测试一把，创建的二叉树
//        System.out.println("赫夫曼树");
//        Node huffmanTreeRoot = createHuffmanTree(nodes);
//        System.out.println("前序遍历");
//        huffmanTreeRoot.preOrder();
//
//        //测试一把是否生成了对应的赫夫曼编码
//        Map<Byte, String> huffmanCodes = getCodes(huffmanTreeRoot);
//        System.out.println("生成的赫夫曼编码表"+huffmanCodes);
//
//        //测试
//        byte[] huffmanCodeBytes = zip(contentBytes, huffmanCodes);
//        System.out.println(Arrays.toString(huffmanCodeBytes));//17}//编写一个方法，完成对压缩文件的解压/**** @param zipFile 要解压的文件的位置* @param dstFile 将文件解压到哪个路径*/public static void unZipFile(String zipFile,String dstFile){//定义文件的输入流InputStream is=null;//定义一个对象输入流ObjectInputStream ois=null;//定义一个文件的输出流OutputStream os=null;try {//创建文件输入流is = new FileInputStream(zipFile);//创建一个和is关联的对象输入流ois = new ObjectInputStream(is);//读取byte数组huffmanBytesbyte[] 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);} catch (Exception e) {e.printStackTrace();} finally {try {is.close();os.close();ois.close();} catch (Exception e) {System.out.println(e.getMessage());}}}//编写方法，将一个文件进行压缩/**** @param srcFile 你传入的希望压缩的文件的全路径* @param dstFile 我们压缩后将压缩文件放到哪个目录*/public static void zipFile(String srcFile,String dstFile){//创建输出流ObjectOutputStream oos=null;OutputStream os=null;FileInputStream is=null;try {//创建文件的输入流is = new FileInputStream(srcFile);//创建一个和源文件大小一样的byte[]byte[] b = new byte[is.available()];//读取文件is.read(b);//直接对源文件进行压缩byte[] huffmanBytes = huffmanZip(b);//创建文件的输出流，存放压缩文件os = new FileOutputStream(dstFile);//创建一个和文件输入流关联的ObjectOutputStreamoos = new ObjectOutputStream(os);//我们赫夫曼编码后的字节数组写入压缩文件oos.writeObject(huffmanBytes);//这里我们以对象流的方式写入赫夫曼编码，是为了以后我们回复源文件时使用//注意一定要包赫夫曼编码写入压缩文件oos.writeObject(huffmanCodes);} catch (Exception e) {System.out.println(e.getMessage());} finally {try {is.close();oos.close();os.close();} catch (Exception e) {System.out.println(e.getMessage());}}}//完成数据的解压//思路//1.将huffmanCodeBytes//重现先转成赫夫曼编码对应的二进制的字符串“0100000//2.、将“111"对照赫夫曼编码=》i like/**** @param huffmanCodes 哈夫曼编码表map* @param huffmanBytes 赫夫曼编码的到的字节数组* @return 原来的字符串对应的数组*///编写一个方法，完成对压缩数据的解码private static byte[] decode(Map<Byte,String> huffmanCodes,byte[] huffmanBytes){//1.先得到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());}
//        System.out.println(map);//创建一个集合，存放byteArrayList<Byte> list = new ArrayList<>();for (int i = 0; i < stringBuilder.length();) {//i可以理解成就是一个索引，扫描stringBuilderint count=1;//小的计数器boolean flag=true;Byte b=null;while (flag){//递增的取出key 1//取出一个字符'1' '0'String key = stringBuilder.substring(i, i + count);//i不动，让count移动，直到匹配到一个字符b=map.get(key);if(b==null){//说明没有匹配到count++;}else {//匹配到flag=false;}}list.add(b);i+=count;//i直接移动到count}//for循环结束后，我们list中就存放了所有的字符"i like"//吧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 b* @param flag 表示是否需要补高位，如果是true，表示需要补高位，如果是false表示不补,如果是最后一个字节，无需补高位* @return 是该b 对应的二进制的字符串，(注意是按补码返回)*/private static String byteToBitString(boolean flag,byte b){//使用变量保存bint temp=b;//b转成int//如果是正数我们还存在补高位的问题if(flag){temp|=256;}String str = Integer.toBinaryString(temp);//返回的是temp对应的二进制补码if(flag){return str.substring(str.length()-8);}else {return str;}}//使用一个方法，将前面的方法封装起来，便于我们的调用/**** @param bytes 原始的字符串对应的字节数组* @return 是经过赫夫曼编码处理后的子节数组(压缩后的数组)*/private static byte[] huffmanZip(byte[] bytes){List<Node> nodes = getNodes(bytes);//根据nodes创建赫夫曼树Node huffmanTreeRoot = createHuffmanTree(nodes);//生成了对应的赫夫曼编码Map<Byte, String> huffmanCodes = getCodes(huffmanTreeRoot);//根据生成的赫夫曼编码，压缩的到压缩后的赫夫曼编码字节数组byte[] huffmanCodeBytes = zip(bytes, huffmanCodes);return huffmanCodeBytes;}/**** @param bytes 这时原始的字符串对应的byte[]* @param huffmanCodes 生成的赫夫曼编码map* @return 返回赫夫曼编码表处理后的byte[]*///编写一个方法，将字符串对应的byte[]数组，通过生成的赫夫曼编码表，返回一个赫夫曼编码压缩有的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));}System.out.println("测试stringBuilder="+stringBuilder.toString());//将1010111011 转成byte数组//统计返回byte[] huffmanCodeBytes 长度//一句话 int len=(stringBuilder.length()+7)/8int len;if(stringBuilder.length()%8==0){len=stringBuilder.length()/8;}else {len=stringBuilder.length()/8+1;}//创建存储压缩有的byte[]byte[] huffmanCodeBytes=new byte[len];int index=0;//记录是第几个bytefor (int i = 0; i < stringBuilder.length(); i+=8) {//因为每8位对应一个byte，所以步长+8String strByte;if(i+8>stringBuilder.length()){//不够8位strByte = stringBuilder.substring(i);}else {strByte = stringBuilder.substring(i, i + 8);}//将strByte转成一个byte，放入到huffmanCodeByteshuffmanCodeBytes[index]= (byte) Integer.parseInt(strByte,2);index++;}return huffmanCodeBytes;}//生成赫夫曼树对应的赫夫曼编码//思路：//1.将赫夫曼编码表存放在Map<Byte,String>形式static Map<Byte,String> huffmanCodes= new HashMap<Byte,String>();// 32->01 97->100...//2.在生成赫夫曼编码表示，需要去拼接璐姐，定义一个StringBuilder存储某个叶子结点的路径static  StringBuilder stringBuilder=new StringBuilder();//这里为了调用方便,我们重载getCodesprivate static Map<Byte,String> getCodes(Node root){if(root==null){return null;}//处理root的左子树getCodes(root.left,"0",stringBuilder);//处理root的右子树getCodes(root.right,"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);//将code加入到stringBuild2stringBuilder2.append(code);if(node!=null){//如果node==null不处理//判断当前node是叶子结点还是非叶子节点if(node.data==null){//非叶子节点//递归处理//向左getCodes(node.left,"0",stringBuilder2);//向右getCodes(node.right,"1",stringBuilder2);}else {//说明是一个叶子结点//表示找到了某个叶子节点的最后huffmanCodes.put(node.data,stringBuilder2.toString());}}}//前序遍历的方法private static void preOrder(Node root){if(root!=null){root.preOrder();}else {System.out.println("赫夫曼树为空");}}/**** @param bytes 接收字节数组* @return 返回的就是List形式*/private static List<Node> getNodes(byte[] bytes){//1.创建一个ArrayListArrayList<Node> nodes = new ArrayList<>();//遍历bytes 统计每一个byte出现的次数->map[key,value]HashMap<Byte, Integer> counts = new HashMap<>();for(byte b:bytes){Integer count=counts.get(b);if (count==null){//map中还没有这个字符数据，第一次counts.put(b,1);}else {counts.put(b,count+1);}}//把每一个键值对转成Node对象，并加入到nodes集合//遍历mapfor(Map.Entry<Byte,Integer> entry:counts.entrySet()){nodes.add(new Node(entry.getKey(),entry.getValue()));}return nodes;}//可以通过List创建对应的赫夫曼树private static Node createHuffmanTree(List<Node> nodes){while (nodes.size()>1){//排序,从小到大Collections.sort(nodes);//取出第一颗最小的二叉树Node leftNode = nodes.get(0);//取出第二颗最小的二叉树Node rightNode = nodes.get(1);//创建一颗新的二叉树，它的根节点没有data，只有权值Node parent=new Node(null,leftNode.weight+rightNode.weight);parent.left=leftNode;parent.right=rightNode;//将已经处理的两颗二叉树从nodes删除nodes.remove(leftNode);nodes.remove(rightNode);//将新的二叉树，加入到nodesnodes.add(parent);}//nodes最后的节点，就是哈夫曼树的根节点return nodes.get(0);}}//创建Node，待数据和权值
class Node implements Comparable<Node>{Byte data;//存放数据(字符)本身，比如'a'=>97 ' '=>32int weight;//权值，表示字符出现的次数Node left;Node right;public Node(Byte data, int weight) {this.data = data;this.weight = weight;}@Overridepublic int compareTo(Node o) {//从小到大排序return this.weight-o.weight;}@Overridepublic String toString() {return "Node{" +"data=" + data +", weight=" + weight +'}';}//前序遍历public void preOrder(){System.out.println(this);if(this.left!=null){this.left.preOrder();}if (this.right!=null){this.right.preOrder();}}}