（Java）哈夫曼编码译码器-压缩/解压缩编码

哈夫曼编码译码器

1. 选择需要进行编码的文件

2.建立哈夫曼树

3.建立密码本并对文件编码

4.选择需要进行解码的文件并解码

5.按位压缩方式对文件进行压缩

6.解压压缩文件为编码文件

一共三个类，Huffman类也是程序的入口

下面的代码中注释将对代码有详细的讲解

public class Node<T> {
   
   //第一个类，可以理解为一个键一个值，很简单
    int key;
    T charData;

    Node leftChild;
    Node rightChild;
}

public class Tree implements Comparable<Tree> {
   
   
    private Node root;

    public Node getRoot() {
   
   
        return root;
    }

    public void setRoot(Node root) {
   
   
        this.root = root;
    }
    /**
     *中序遍历
     */
    public void inDisplay(Node node){
   
   //递归遍历，左根右
        if (node!=null){
   
   
            inDisplay(node.leftChild);
            System.out.println(node.key+":"+node.charData);
            inDisplay(node.rightChild);
        }
    }

    @Override
    public int compareTo(Tree o) {
   
   
        return 0;
    }
}

到这为止都没什么好说的，没涉及到什么算法，也没有复杂的操作，接下来是代码的核心(带注释)

package Misson6_bing;
import 实验3.KeyInput;

import java.awt.event.KeyEvent;
import java.io.*;

import java.util.HashMap;
import java.util.Map;
import java.util.PriorityQueue;

public class Huffman {
   
   
    private Map<Character,Integer> map=new HashMap<>();//存元素的哈希表
    private Map<Character,String> ce=new HashMap<>();//密码本哈希表
    private PriorityQueue<Tree> trees=new PriorityQueue<>();//无界优先级队列
    private String source;

    public void init(String source){
   
   
        this.source=source;
        char[] chars= source.toCharArray();//String转char
        for (char c :chars){
   
   //迭代
            if (!map.containsKey(c)){
   
   //若无当前元素 放入map
                map.put(c,1);
            }else {
   
   
                map.put(c,map.get(c)+1);//有 则计数+1
            }
        }
        afterInit();
    }

    private void afterInit() {
   
   
        map.forEach((c,count)->{
   
   //迭代送入树中->按优先级排序
            Node<Character> node=new Node<>();
            node.key=count;
            node.charData=c;
            Tree tree=new Tree();
            tree.setRoot(node);
            trees.add(tree);
        });
    }

    public void build(){
   
   
        while (this.trees.size()>1){
   
   //取两个加一个，队列中只剩下一个元素时结束
            Tree left=this.trees.poll();//队首获取元素，同时获取的这个元素将从原队列删除
            Tree right=this.trees.poll();//队首获取元素，同时获取的这个元素将从原队列删除
                                           //每次从队首获取的两个元素是最小的两个，第二次开始获取的元素有一个是原本队列中的，
                                         // 另一个是新add进来的上一次的根节点，值是上一次两个子树的值的和
            Node node=new Node();
            node.key=left.getRoot().key+right.getRoot().key;//根结点的值为左右子树之和
            node.leftChild=left.getRoot();
            node.rightChild=right.getRoot();
            left.setRoot