用Java实现【哈夫曼树】的数据压缩
关于哈夫曼树入门请看上节 《用Java实现【哈夫曼树】》
本文代码文件哈夫曼树完整代码
哈夫曼树基本代码
//1. 将赫夫曼编码表存放在 Map 形式
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());
}
}