无损的压缩算法 java

无损压缩算法 Java

简介

无损压缩算法是一种能够减小文件大小而保持数据完整性的算法。在计算机科学领域，我们经常需要处理大量的数据，而这些数据可能会占用很大的存储空间。无损压缩算法通过对数据进行编码和解码的方式，能够在不丢失任何信息的情况下，将数据的大小减小到最小。

Java 是一种功能强大的编程语言，拥有丰富的库和工具，可以用来实现各种无损压缩算法。本文将介绍一些常见的无损压缩算法，并使用 Java 代码提供示例。

常见的无损压缩算法

Huffman 压缩算法

Huffman 压缩算法是一种基于字符出现频率的压缩方法。它通过构建一个 Huffman 树来生成一种特殊的编码，将出现频率高的字符用较短的编码表示，而出现频率低的字符用较长的编码表示。这样可以大大减小表示数据所需的位数。

以下是一个使用 Huffman 压缩算法的 Java 代码示例：

import java.util.PriorityQueue;

class HuffmanNode implements Comparable<HuffmanNode> {
    int data;
    char c;
    HuffmanNode left;
    HuffmanNode right;

    public int compareTo(HuffmanNode node) {
        return data - node.data;
    }
}

class HuffmanCompressor {
    public static void compress(String data) {
        int[] freq = new int[256];
        for (char c : data.toCharArray()) {
            freq[c]++;
        }

        PriorityQueue<HuffmanNode> pq = new PriorityQueue<>();
        for (int i = 0; i < 256; i++) {
            if (freq[i] > 0) {
                HuffmanNode node = new HuffmanNode();
                node.c = (char) i;
                node.data = freq[i];
                pq.offer(node);
            }
        }

        while (pq.size() > 1) {
            HuffmanNode left = pq.poll();
            HuffmanNode right = pq.poll();
            HuffmanNode parent = new HuffmanNode();
            parent.data = left.data + right.data;
            parent.left = left;
            parent.right = right;
            pq.offer(parent);
        }

        HuffmanNode root = pq.poll();
        printCodes(root, "");
    }

    public static void printCodes(HuffmanNode node, String code) {
        if (node.left == null && node.right == null && Character.isLetter(node.c)) {
            System.out.println(node.c + ": " + code);
            return;
        }

        printCodes(node.left, code + "0");
        printCodes(node.right, code + "1");
    }
}

public class Main {
    public static void main(String[] args) {
        String data = "Hello, World!";
        HuffmanCompressor.compress(data);
    }
}

LZW 压缩算法

LZW 压缩算法是一种基于字典的压缩方法。它维护一个字典，将输入数据中的短字符串映射到唯一的编码。在压缩过程中，如果遇到新的字符串，就将它添加到字典中，并为它分配一个新的编码。在解压过程中，通过读取编码并查找字典，可以将编码还原为原始字符串。

以下是一个使用 LZW 压缩算法的 Java 代码示例：

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

class LZWCompressor {
    public static void compress(String data) {
        Map<String, Integer> dictionary = new HashMap<>();
        for (int i = 0; i < 256; i++) {
            dictionary.put(Character.toString((char) i), i);
        }

        StringBuilder compressedData = new StringBuilder();
        String current = "";
        int code = 256;

        for (char c : data.toCharArray()) {
            String combined = current + c;
            if (dictionary.containsKey(combined)) {
                current = combined;
            } else {
                compressedData.append(dictionary.get(current)).append(" ");
                dictionary.put(combined, code++);
                current = Character.toString(c);
            }
        }

        if (!current.equals("")) {
            compressedData.append(dictionary.get(current));
        }

        System.out.println(compressedData.toString());
    }
}

public class Main {
    public static void main(String[] args) {
        String data = "ABABABA";
        LZWCompressor.compress(data);
    }
}