最终达到的效果:
调用一个类
class HuffmanCodin{.....}
使用类中的静态方法，获取哈夫曼编码：
事前准备——哈夫曼树的节点定义
class Node implements Comparable<Node> {int weight;//权重Node left;Node right;char ch;//关键字，字符String code;//相应的哈夫曼编码public Node(char ch, int weight) {//构造方法，键值对this.weight = weight;this.ch = ch;}//构造方法，只设置出现频率public Node(int weight) {this.weight = weight;}//重写compareTo方法@Overridepublic int compareTo(Node node) {if(this.weight - node.weight==0){//如果两个字符出现的频率一样，那么就比较字典序（两个字符一定是不同的）return this.ch-node.ch;}return this.weight - node.weight;//默认排列升序}//重写toString方法
//效果：[ 字符 -> 010 ]@Overridepublic String toString() {//重写之后，等一下打印就可以直接用引用就可以了return "[" + this.ch + " -> " + this.code + "] ";}}步骤：
想要达到上述效果，大致可以分为这几步：
1、字符集转化成一个一个的键值对；
2、键值对转节点，节点放入一个集合
3、依据集合创建哈夫曼树。
4、对哈夫曼树的叶子节点进行哈夫曼编码
下面我们一点一点来解决
1、字符集转键值对
这里就要使用到HashMap了：
HashMap的
Key=一个字符
Value=权重（就是一个字符在字符集出现的频率，当然也不完全是，等一下会讲到）
public class Test {public static void main(String[] args) {Scanner in = new Scanner(System.in);System.out.println("输入的字符集：");String arr = in.nextLine();char[] chars = arr.toCharArray();//转化成字符数组Node root=HuffmanCoding.createTree(chars);//调用这个静态方法，具体实现看下一块代码 }}class HuffmanCoding {public static Node createTree(char[] arr) {Map.Entry<Character, Integer>[] entries = charGetEntry(arr);//获取键值对}charGetEntry（）方法就是专门用来把字符集转化成一个一个的键值对的，然后返回这个类型：
Map.Entry<Character, Integer>[]
为什么是这个类型？
因为HashMap不能直接同时访问Character也就是字符，以及Integer接也就是对应字符的权重。
如果要访问键值对，需要调用HashMap的setEntry方法，setEntry方法会返回Map.Entry<Character, Integer>[]类型的数组
而Map.Entry中有访问和修改关键字和值的方法。
charGetEntry（）方法：
private static Map.Entry<Character, Integer>[] charGetEntry(char[] arr) {//定义Hashmap储存不重复的键值对Map<Character, Integer> map = new HashMap<>(arr.length);//长度肯定不会超过arr的长度for (char ch : arr) {map.put(ch, 0);//权值默认先给0，等一下处理}//定义Entry[]这个集合，用来存放键值对Map.Entry<Character, Integer>[] entrys = new Map.Entry[map.size()];//长度刚好就是map的长度int i = 0;for (Map.Entry<Character, Integer> entry : map.entrySet()) {//遍历每一个entry，以此把每一个键值对放到集合entrys中entrys[i++] = entry;}//现在就可以赋值weight了i=entrys.length-1;//从后往前遍历，当然从前往后也可以while(i>=0){int n=0;for (int j = 0; j <arr.length ; j++) {if(entrys[i].getKey()==arr[j]){//两个字符一样，那么频率++n++;}}entrys[i--].setValue(n);}//程序到达这里，键值对已经储存完毕，下面直接返回集合即可return entrys;}如下第一步完成：
2、键值对转节点
上一步我们已经获得了所有的键值对，储存在entries中，现在只需创建一个List<Node>类型的集合，获遍历entries，获取键值对即可：
//放入节点中(用集合来管理)int length = entries.length;List<Node> nodeList = new ArrayList<>(length);//长度一定和entries是一样的while (length > 0) {//用Node的构造方法，创建结点，第一个参数是关键子，第二个参数是权重nodeList.add(new Node(entries[length - 1].getKey(), entries[length - 1].getValue()));length--;}
此时，第二步完成，nodeList就是一个储存着所有结点的集合。
3、构造哈夫曼树
此时类
HuffmanCoding
的静态方法createTree已经定义好了：
public static Node createTree(char[] arr) {Map.Entry<Character, Integer>[] entries = charGetEntry(arr);//获取键值对，已经完成，保存在了entries中//放入节点中(用集合来管理)int length = entries.length;List<Node> nodeList = new ArrayList<>(length);//长度一定和entries是一样的while (length > 0) {nodeList.add(new Node(entries[length - 1].getKey(), entries[length - 1].getValue()));length--;}while (nodeList.size() > 1) {//只要大于一，就合并Collections.sort(nodeList);//先排升序，重写了用weight比较Node a = nodeList.remove(0);Node b = nodeList.remove(0);Node newNode = new Node(a.weight + b.weight);//这个是双亲节点newNode.left = a;newNode.right = b;nodeList.add(newNode);}return nodeList.remove(0);//还剩下的一个节点，就是哈夫曼树的根节点}
4、叶结点编码
下面运用的是递归，对叶子结点进行赋值0或者1（左结点是0，右结点时1）：
//这个函数可以把Node的code修改public static void coding(Node root, StringBuilder sb) {if (root == null) return;//如果只有一个节点，code==“”---->空字符串root.code = sb.toString();//先根节点if (root.left == null && root.right == null) {return;//直接返回}//如果不是叶子节点，那么一定有左右孩子----》因为这是哈夫曼树sb.append("0");//先左边，所以加一个0coding(root.left, sb);//递归sb.replace(sb.length() - 1, sb.length(), "1");//把最后一个替换成1，因为要走右边了coding(root.right, sb);//递归sb.delete(sb.length() - 1, sb.length());//也要删除，删除的区间是：左开右闭的！}现在这个HuffmanCoding这个类就可以对一个字符集进行哈夫曼编码了，当然如果想要打印对应的值，需要写一个打印叶子结点的方法：
//前序遍历打印叶子结点public static void showChar(Node root) {if (root == null) return;if (root.left == null && root.right == null) {//这是一个叶子节点，直接打印然后返回System.out.println(root);return;}//不是叶子结点，就遍历左右子树showChar(root.left);showChar(root.right);}测试
最终哈夫曼编码类的源码：
class HuffmanCoding {public static Node createTree(char[] arr) {Map.Entry<Character, Integer>[] entries = charGetEntry(arr);//获取键值对，已经完成，保存在了entries中//放入节点中(用集合来管理)int length = entries.length;List<Node> nodeList = new ArrayList<>(length);//长度一定和entries是一样的while (length > 0) {nodeList.add(new Node(entries[length - 1].getKey(), entries[length - 1].getValue()));length--;}while (nodeList.size() > 1) {//只要大于一，就合并Collections.sort(nodeList);//先排升序，重写了用weight比较Node a = nodeList.remove(0);Node b = nodeList.remove(0);Node newNode = new Node(a.weight + b.weight);//这个是双亲节点newNode.left = a;newNode.right = b;nodeList.add(newNode);}return nodeList.remove(0);//还剩下的一个节点，就是哈夫曼树的根节点}private static Map.Entry<Character, Integer>[] charGetEntry(char[] arr) {//定义Hashmap储存不重复的键值对Map<Character, Integer> map = new HashMap<>(arr.length);//长度肯定不会超过arr的长度for (char ch : arr) {map.put(ch, 0);//权值默认先给0，等一下处理}//定义Entry[]，又来放键值对（可以访问的）Map.Entry<Character, Integer>[] entrys = new Map.Entry[map.size()];//长度刚好就是map的长度int i = 0;for (Map.Entry<Character, Integer> entry : map.entrySet()) {entrys[i++] = entry;}//先在赋值weighti=entrys.length-1;while(i>=0){int n=0;for (int j = 0; j <arr.length ; j++) {if(entrys[i].getKey()==arr[j]){//两个字符一样，那么频率佳佳n++;}}entrys[i--].setValue(n);}//程序到达这里，键值对已经储存完毕return entrys;}//这个函数可以把Node的code修改public static void coding(Node root, StringBuilder sb) {if (root == null) return;//如果只有一个节点，code==“”---->空字符串root.code = sb.toString();//先根节点if (root.left == null && root.right == null) {return;//直接返回}//如果不是叶子节点，那么一定有左右孩子----》因为这是哈夫曼树sb.append("0");//先左边，所以加一个0coding(root.left, sb);//递归sb.replace(sb.length() - 1, sb.length(), "1");//把最后一个替换成1，因为要走右边了coding(root.right, sb);//递归sb.delete(sb.length() - 1, sb.length());//也要删除，删除的区间是：左开右闭的！}//前序遍历打印叶子结点public static void showChar(Node root) {if (root == null) return;if (root.left == null && root.right == null) {//这是一个叶子节点，直接打印然后返回System.out.println(root);return;}//不是叶子结点，就遍历左右子树showChar(root.left);showChar(root.right);}}
类中静态方法使用的演示：
关于哈夫曼编码的解码
会了编码，其实解码就很容易了
值得注意的是：
不同的字符集合，对应的哈夫曼编码是有所差异的
所以如果要进行解码，那么必须直到每一个字符对应出现的频率
解码思路：
在接收到字符频度表之后，创建一颗哈夫曼树，每次从root结点开始遍历，从第一个字符开始，是0就往左树走，是1就往右走，直到叶子结点即可解码。
具体实现：
public static void deCoding(Map.Entry<Character, Integer>[] arrEntry, String arr) {//需要接收字符频度表 and 哈夫曼编码Node Cur= createTree(arrEntry);//调用了重载的创建哈夫曼树的方法char[] chars = arr.toCharArray();int cur = 0;//表示读取编码的位置Node root=Cur;//Cur保存了哈夫曼树的根结点while (cur < chars.length) {//读完就退出循环while (root.left != null && root.right != null) {//没有到叶子结点就一直循环if (chars[cur] == '1') {//是1走右边cur++;root = root.right;} else {//是二走左边cur++;root = root.left;}}//如果跳出了循环说明已经是叶子结点了System.out.println(root);root=Cur;}}
因为我们在createTree()方法中传入的类型是Map.Entry<Character, Integer>[]，
所以需要对createTree()方法，
进行一次重载，
这个重载其实不麻烦，只要改一下接口，就可以了：
private static Node createTree(Map.Entry<Character, Integer>[] entries){//重载方法，用在解码时调用这个方法//放入节点中(用集合来管理)int length = entries.length;//只改了这一行，和方法的唯一参数！！！！！List<Node> nodeList = new ArrayList<>(length);//长度一定和entries是一样的while (length > 0) {nodeList.add(new Node(entries[length - 1].getKey(), entries[length - 1].getValue()));length--;}while (nodeList.size() > 1) {//只要大于一，就合并Collections.sort(nodeList);//先排升序，重写了用weight比较Node a = nodeList.remove(0);Node b = nodeList.remove(0);Node newNode = new Node(a.weight + b.weight);//这个是双亲节点newNode.left = a;newNode.right = b;nodeList.add(newNode);}return nodeList.remove(0);//还剩下的一个节点，就是哈夫曼树的根节点}
