Алгоритмы сжатия данных (RLE и алгоритм Хаффмана)

public class RLE1 {
    public static String compress(String text) {
        StringBuilder sb = new StringBuilder();
        for (int textIndex = 0; textIndex < text.length(); textIndex++) {
            int charCount = 1;
            while (textIndex < text.length() - 1 && text.charAt(textIndex) == text.charAt(textIndex + 1)) {
                charCount++;
                textIndex++;
            }
            sb.append(text.charAt(textIndex)).append(charCount);
        }
        return sb.toString();
    }
 
    public static void main(String[] args) {
        String initialText = " ";
        String encodedText = compress(initialText);
        System.out.println(encodedText);
    }
}

import java.util.*;
import static java.util.Objects.requireNonNull;
 
public class Huffman {
 
    private Node root;
    private final String text;
    private Map<Character, Integer> charFrequencies;
    private final Map<Character, String> huffmanCodes;
 
    public Huffman(String text) {
        this.text = text;
        fillCharFrequenciesMap();
        huffmanCodes = new HashMap<>();
    }
 
    private void fillCharFrequenciesMap() {
        charFrequencies = new HashMap<>();
        for (char character : text.toCharArray()) {
            charFrequencies.put(character, charFrequencies.getOrDefault(character, 0) + 1);
        }
    }
 
    public String encode() {
        Queue<Node> queue = new PriorityQueue<>();
        charFrequencies.forEach((character, frequency) ->
                queue.add(new Leaf(character, frequency))
        );
        while (queue.size() > 1) {
            queue.add(new Node(queue.poll(), requireNonNull(queue.poll())));
        }
        generateHuffmanCodes(root = queue.poll(), "");
        return getEncodedText();
    }
 
    private void generateHuffmanCodes(Node node, String code) {
        if (node instanceof Leaf leaf) {
            huffmanCodes.put(leaf.getCharacter(), code);
            return;
        }
        generateHuffmanCodes(node.getLeftNode(), code.concat("0"));
        generateHuffmanCodes(node.getRightNode(), code.concat("1"));
    }
 
    private String getEncodedText() {
        StringBuilder sb = new StringBuilder();
        for (char character : text.toCharArray()) {
            sb.append(huffmanCodes.get(character));
        }
        return sb.toString();
    }
 
    public void printCodes() {
        huffmanCodes.forEach((character, code) ->
                System.out.println(character + ": " + code)
        );
    }
 
    public static void main(String[] args) {
        Huffman huffman = new Huffman("");
        String encodedText = huffman.encode();
        System.out.println(encodedText);
        huffman.printCodes();
 
        String str = "";
        String result = "";
        char[] messChar = str.toCharArray();
        for (int i = 0; i < messChar.length; i++) {
            result += Integer.toBinaryString(messChar[i]) + "";
        }
        System.out.println(result);
    }
}

import lombok.Getter;
import lombok.RequiredArgsConstructor;
 
@Getter
@RequiredArgsConstructor
public class Node implements Comparable<Node> {
 
    private final int frequency;
    private Node leftNode;
    private Node rightNode;
 
    public Node(Node leftNode, Node rightNode) {
        this.leftNode = leftNode;
        this.rightNode = rightNode;
        this.frequency = leftNode.getFrequency() + rightNode.getFrequency();
    }
 
    @Override
    public int compareTo(Node node) {
        return Integer.compare(frequency, node.getFrequency());
    }
 
}

import lombok.EqualsAndHashCode;
import lombok.Getter;
 
@Getter
@EqualsAndHashCode(callSuper = true)
public class Leaf extends Node {
 
    private final char character;
 
    public Leaf(char character, int frequency) {
        super(frequency);
        this.character = character;
    }
}

        String str = "";
        String result = "";
        char[] messChar = str.toCharArray();
        for (int i = 0; i < messChar.length; i++) {
            result += Integer.toBinaryString(messChar[i]) + "";
        }
        System.out.println(result);