在Java上运行规范霍夫曼代码的参考代码问题

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

class HuffmanNode implements Comparable<HuffmanNode> {
    char character;
    int frequency;
    HuffmanNode left;
    HuffmanNode right;

    public HuffmanNode(char character, int frequency) {
        this.character = character;
        this.frequency = frequency;
    }

    @Override
    public int compareTo(HuffmanNode node) {
        return this.frequency - node.frequency;
    }
}

public class HuffmanCoding {
    public static void main(String[] args) {
        String text = "Hello, World!";
        Map<Character, Integer> frequencyMap = getFrequencyMap(text);
        HuffmanNode root = buildHuffmanTree(frequencyMap);
        Map<Character, String> codeMap = getCodeMap(root);
        String encodedText = encodeText(text, codeMap);
        String decodedText = decodeText(encodedText, root);
        System.out.println("Original text: " + text);
        System.out.println("Encoded text: " + encodedText);
        System.out.println("Decoded text: " + decodedText);
    }

    private static Map<Character, Integer> getFrequencyMap(String text) {
        Map<Character, Integer> frequencyMap = new HashMap<>();
        for (char c : text.toCharArray()) {
            frequencyMap.put(c, frequencyMap.getOrDefault(c, 0) + 1);
        }
        return frequencyMap;
    }

    private static HuffmanNode buildHuffmanTree(Map<Character, Integer> frequencyMap) {
        PriorityQueue<HuffmanNode> priorityQueue = new PriorityQueue<>();
        for (Map.Entry<Character, Integer> entry : frequencyMap.entrySet()) {
            priorityQueue.offer(new HuffmanNode(entry.getKey(), entry.getValue()));
        }
        while (priorityQueue.size() > 1) {
            HuffmanNode leftChild = priorityQueue.poll();
            HuffmanNode rightChild = priorityQueue.poll();
            HuffmanNode parent = new HuffmanNode('\0', leftChild.frequency + rightChild.frequency);
            parent.left = leftChild;
            parent.right = rightChild;
            priorityQueue.offer(parent);
        }
        return priorityQueue.poll();
    }

    private static Map<Character, String> getCodeMap(HuffmanNode root) {
        Map<Character, String> codeMap = new HashMap<>();
        generateCodeMap(root, "", codeMap);
        return codeMap;
    }

    private static void generateCodeMap(HuffmanNode node, String code, Map<Character, String> codeMap) {
        if (node.left == null && node.right == null) {
            codeMap.put(node.character, code);
            return;
        }
        generateCodeMap(node.left, code + "0", codeMap);
        generateCodeMap(node.right, code + "1", codeMap);
    }

    private static String encodeText(String text, Map<Character, String> codeMap) {
        StringBuilder encodedText = new StringBuilder();
        for (char c : text.toCharArray()) {
            encodedText.append(codeMap.get(c));
        }
        return encodedText.toString();
    }

    private static String decodeText(String encodedText, HuffmanNode root) {
        StringBuilder decodedText = new StringBuilder();
        HuffmanNode currentNode = root;
        for (char c : encodedText.toCharArray()) {
            if (c == '0') {
                currentNode = currentNode.left;
            } else {
                currentNode = currentNode.right;
            }
            if (currentNode.left == null && currentNode.right == null) {
                decodedText.append(currentNode.character);
                currentNode = root;
            }
        }
        return decodedText.toString();
    }
}