Java课程设计——哈夫曼编码译码系统的Java语言实现（附Java源码与课程设计报告）

以下都是我在CSDN发布是文章好吧。

数据库课程设计——某工厂的物料管理系统（附Java源码与课程设计报告）
数据库课程设计——某商店进销存管理系统（附Java源码与课程设计报告）
数据库课程设计——某煤气公司送气管理系统（附课设报告）
数据库课程设计——基于JavaEE的企业进销存系统（附Java源码与课程设计报告）
Java课程设计——哈夫曼编码译码系统的Java语言实现
C语言课程设计——班级成绩管理系统（附课设报告）
C语言课程设计——排班系统 DFS解决（附课设报告）

0. 系统展示

1. 系统类图

2. 课程设计报告

3. 部分源码展示

import java.io.*;
import java.text.NumberFormat;
import java.util.HashMap;
import java.util.Map;
import java.util.PriorityQueue;

public class HuffmanEncoder implements DataShare {
    private String fileName;
    private Node huffmanTree;
    private HashMap<Character, Integer> charFrequencies;
    private HashMap<Character, String> huffmanCodeMap;
    private String text;
    private String encodedText;
    /*private static final String treeExportPath = "G:\\project\\test data\\HuffmanTree.txt";
    private static final String encodedTextExportPath = "G:\\project\\test data\\EncodedText.txt";*/
    private static final String treeExportPath = "HuffmanTree.txt";
    private static final String encodedTextExportPath = "EncodedText.txt";

    HuffmanEncoder(String fileName) {
        // just don't want to fold the code
        this.fileName = fileName;
        charFrequencies = new HashMap<>();
    }

    public String getEncodedText() {
        // just don't want to fold the code
        return encodedText;
    }

    public String getText() {
        // just don't want to fold the code
        return text;
    }

    private void getCharFrequencies() {
        int ch;
        StringBuilder textBuilder = new StringBuilder();
        try {
            Reader in = new FileReader(fileName);
            while ((ch = in.read()) != -1) {
                char c = (char)ch;
                textBuilder.append(c);
                charFrequencies.put(c, charFrequencies.containsKey(c) ? charFrequencies.get(c) + 1 : 1);
            }
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        text = textBuilder.toString();
    }

    private void createHuffmanTree() {
        // 优先级队列的元素按照其自然顺序进行排序，或者根据构造队列时提供的 Comparator 进行排序，具体取决于所使用的构造方法
        PriorityQueue<Node> priorityQueue = new PriorityQueue<Node>();
        // Map.Entry<K,V>接口 映射项（键-值对）
        // 类HashMap<K,V>的方法 Set<Map.Entry<K,V>> entrySet() 返回此映射所包含的映射关系的 Set 视图
        for (Map.Entry<Character, Integer> kv : charFrequencies.entrySet()) {
            priorityQueue.add(new Node(kv.getKey(), kv.getValue(), null, null));
        }
        while (priorityQueue.size() > 1) {
            Node node1 = priorityQueue.poll();
            // System.out.print(node1.ch);
            Node node2 = priorityQueue.poll();
            // System.out.print(node2.ch);
            priorityQueue.add(new Node('\0', node1.freq + node2.freq, node1, node2));
        }
        huffmanTree = priorityQueue.poll();
    }

    private void createHuffmanCode(Node node, HashMap<Character, String> hashMap, String string) {
        if (node.lChild == null && node.rChild == null) {
            hashMap.put(node.ch, string);
            return;
        }
        createHuffmanCode(node.lChild, hashMap, string + '0');
        createHuffmanCode(node.rChild, hashMap, string + '1');
    }

    private void getHuffmanCode() {
        huffmanCodeMap = new HashMap<>();
        createHuffmanCode(huffmanTree, huffmanCodeMap, "");
    }

    private void encode() {
        StringBuilder encodedTextBuilder = new StringBuilder();
        for (char ch : text.toCharArray()) {
            encodedTextBuilder.append(huffmanCodeMap.get(ch));
        }
        encodedText = encodedTextBuilder.toString();
        /*try {
            int ch;
            Reader in = new FileReader(fileName);
            while ((ch = in.read()) != -1) {
                encodedTextBuilder.append(huffmanCodeMap.get((char) ch));
            }
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        encodedText = encodedTextBuilder.toString();*/
    }

    private void exportEncodedText() throws IOException {
        // G:\project\test data\Red history thriving along highway.txt
        File file = new File(encodedTextExportPath);
        if (file.createNewFile()) {
            RandomAccessFile out = new RandomAccessFile(file, "rw");
            out.writeBytes(encodedText);
        }
    }

    private void exportHuffmanTree() {
        File file = new File(treeExportPath);
        try {
            FileOutputStream fileOutputStream = new FileOutputStream(file);
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(huffmanTree);
            objectOutputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public String calculateCompressionRatio() {
        File text = new File(fileName);
        File encodedText = new File(encodedTextExportPath);
        /*System.out.println(text.length());
        System.out.println(encodedText.length());*/
        String ratio = String.format("%.4f", (double)encodedText.length() / (double)text.length() / 16.0);
        return NumberFormat.getPercentInstance().format(Double.parseDouble(ratio));
    }

    public Object[][] getFileData() {
        File textFile = new File(fileName);
        File encodedTextFile = new File(encodedTextExportPath);

        Object[][] fileData = new Object[2][3];
        fileData[0][0] = textFile.getName();
        fileData[0][1] = textFile.length();
        fileData[0][2] = textFile.getAbsolutePath();
        fileData[1][0] = encodedTextFile.getName();
        fileData[1][1] = encodedTextFile.length() / 16;
        fileData[1][2] = encodedTextFile.getAbsolutePath();

        return fileData;
    }

    public Object[][] getCodingData() {
        Object[][] codingData = new Object[charFrequencies.size()][3];
        int count = 0;
        for (Map.Entry<Character, Integer> kv : charFrequencies.entrySet()) {
            codingData[count][0] = kv.getKey();
            codingData[count][1] = kv.getValue();
            ++count;
        }
        count = 0;
        for (Map.Entry<Character, String> kv : huffmanCodeMap.entrySet()) {
            codingData[count][2] = kv.getValue();
            ++count;
        }
        return codingData;
    }

    public void execute() throws IOException {
        getCharFrequencies();
        createHuffmanTree();
        getHuffmanCode();
        encode();
        exportHuffmanTree();
        exportEncodedText();
    }

    /*public void showHuffmanCodeMap() {
        for (Map.Entry<Character, String> kv : huffmanCodeMap.entrySet()) {
            System.out.println(kv.getKey() + " : " + kv.getValue());
        }
    }

    public void showCharFrequencies() {
        for (Map.Entry<Character, Integer> kv : charFrequencies.entrySet()) {
            System.out.println(kv.getKey() + " : " + kv.getValue());
        }
    }

    public static void main(String[] args) throws IOException {
        HuffmanEncoder en = new HuffmanEncoder();
        en.setFileName("G:\\project\\src\\test.txt");
        en.getCharFrequencies();
        en.createHuffmanTree();
        en.getHuffmanCode();
        en.encode();
        en.exportHuffmanTree();
        en.showCharFrequencies();
        en.exportEncodedText();
        System.out.println(en.encodedText);
        System.out.println(en.calculateCompressionRatio());
    }*/

}

4. 资源展示