常见压缩算法学习

最新推荐文章于 2024-08-10 07:17:46 发布
最新推荐文章于 2024-08-10 07:17:46 发布
阅读量4.9k 收藏 21
点赞数 3
分类专栏： 杂乱无章 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dreamzuora/article/details/108793360
版权

文章目录

无损压缩算法理论基础

信息熵

信息熵是一个数学上颇为抽象的概念，在这里不妨把信息熵理解成某种特定信息的出现概率（离散随机事件的出现概率）。一个系统越是有序，信息熵就越低；反之，一个系统越是混乱，信息熵就越高。信息熵也可以说是系统有序化程度的一个度量。

  1. 熵编码：根据消息中每个符号出现的概率，然后通过某种映射用更短的符号替代原来的符号，核心在于提高符号的
  2. 字典编码：提取信息中的重复部分作为字典，然后通过字典和某种映射替代这些重复的部分，核心在于替代重复

熵编码

  1. 赫夫曼编码：根据消息中符号出现的频率构建出霍夫曼树，实现频率高的符号编码短，然后根据霍夫曼树得到新的符号替代原来的符号
  2. 算术编码：根据消息中符号出现的概率算出整个消息（符号串）的概率，一个满足（0.0 ≤ n < 1.0）的小数 n ，这个小数n就代表了这个消息
  3. 区间编码：根据消息中符号出现的概率把符号串映射到大区间数值中的一段小区间（多个符号多次细分区），用小区间边缘的数值的唯一前缀就可以代表了这个区间对应的消息（效果其实和算术编码相同）

字典编码

  1. RLE（Run-length Encoding）游程编码: 个人把他看作一种比较直觉朴素的字典编码，具体算法就是把字符串中重复出现的多个字符替换为重复次数外加这个字符
  2. MTF(Move-to-front transform): 通过护“recently used symbols”最近访问过的字符栈表，作为一个动态字典，在编码消息时，用字符在栈表中的索引序号替代，同时调整栈表中该字符到栈顶，根据“空间局部性”原理可以实现数据压缩
  3. LZ77与LZ78： 典型的字典编码，较早出现并流行的两种通用压缩算法。LZ77：通过滑动窗口”slidingwindow”实现动态字典，用前面出现过的字符串作为字典通过映射（与前一个字符串的距离和字符串长度）替代后面重复出现的字符串；LZ78：提前解析输入数据，生成一个静态字典
  4. LZSS： 衍生于LZ77，能检测到一个替换是否真的减小了文件大小，以及一些别的优化
  5. LZW： 衍生于LZ78，优化了字典编码存储，但由于专利限制了发展，在GIF中被使用

综合通用无损压缩算法

  1. deflate:先用LZ77（或 LZSS）算法预处理，然后用霍夫曼编码对压缩后的 literal、length、distance 编码优化，如今最流行的通用压缩算法之一
  2. bzip2：涉及多种算法，主要流程包括先使用 Run-length Encoding 游程编码对原始数据进行处理，然后通过 Burrows-Wheeler Transform 转换（可逆的处理一段输入数据使得相同字符连续出现的次数最大化），再用 Move-to-front transform 转换，然后再次使用Run-length Encoding游程编码处理，接下来还会进行霍夫曼编码以及一系列相关处理，较为复杂，速率劣于DEFLATE但压缩率更高
  3. LZMA：实现了LZ77修改版以位（bit）而非字节（byte）为单元级别的操作，并通过马可夫链实现字典索引，速率和压缩率优于bzip2，另有多线程优化的版本LZMA2
  4. Brotli： 基于LZ77算法的一个现代变体，使用了霍夫曼编码和二阶上下文建模，使用了预定义的120千字节字典包含超过13000个常用单词、短语和其他子字符串，预定义的算法可以提升较小文件的压缩密度。总体速率接近于DEFLATE且压缩率接近于LZMA

相关常见名词说明

  1. RAR： 商业软件WinRAR提供的压缩文件格式，压缩算法实现带专利（可能衍生自LZSS）
  2. Zip： 一种规范开放的压缩文件容器，被多种压缩软件实现，兼容多种压缩算法主要为DEFLATE
  3. GZip： gnu/Linux下的文件压缩软件，提供gz压缩格式，压缩算法基于DEFLATE
  4. 7-Zip： 开源跨平台压缩软件，提供7z压缩格式，压缩算法主要为Bzip2以及LZMA

java对几种常见算法实现

Snappy

Google开发的一个非常流行的压缩算法，基于LZ77的思路编写的快速数据压缩与解压缩
nappy是在谷歌内部生产环境中被许多项目使用的压缩库，包括BigTable，MapReduce和RPC等。谷歌表示算法库针对性能做了调整，而不是针对压缩比或与其他类似工具的兼容性。在Intel酷睿i7处理器上，其单核处理数据流的能力达到250M/s-500M/s。Snappy同时针对64位x86处理器进行了优化，在英特尔酷睿i7处理器单一核心实现了至少250MB/s的压缩性能和500MB/ s的解压缩性能。Snappy对于纯文本的压缩率为1.5-1.7，对于HTML是2-4，当然了对于JPEG、PNG和其他已经压缩过的数据压缩率为1.0。谷歌强劲吹捧Snappy的鲁棒性，称其是“即使面对损坏或恶意输入也不会崩溃的设计”，并且在谷歌的生产环境中经过了PB级数据压缩的考验而稳定的。

依赖：

        <dependency>
            <groupId>org.xerial.snappy</groupId>
            <artifactId>snappy-java</artifactId>
            <version>1.1.7.5</version>
        </dependency>

Snappy java实现源码：

package com.demo.rpc.compress;


import java.io.IOException;

import org.xerial.snappy.Snappy;

/**
 *  @author: weijie
 *  @Date: 2020/9/24 14:31
 *  @Description:Google开发的一个非常流行的压缩算法，基于LZ77的思路编写的快速数据压缩与解压缩
 *
 *  LZ77算法：如果文件中有两块内容相同的话，那么只要知道前一块的位置和大小，我们就可以确定后一块的内容
 *  所以我们可以用(两者之间的距离，相同内容的长度)这样一对信息，来替换后一对内容。由于(两者之间的距离，相同
 *  内容的长度)这一对信息的大小，小于被替换内容的大小，所以文件得到压缩。
 *
 * @url: https://blog.csdn.net/zj57356498318/article/details/108248602
 *
 *
 *
 */
public class SnappyCompressor implements Compressor {

    public byte[] compress(byte[] array) throws IOException {
        if (array == null) {
            return null;
        }
        return Snappy.compress(array);
    }

    public byte[] unCompress(byte[] array) throws IOException {
        if (array == null) {
            return null;
        }
        return Snappy.uncompress(array);
    }
}

deflate算法

package com.demo.rpc.compress;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.InflaterInputStream;

public class DeflateCompress {

    //deflate解压缩
    public static String unCompress(String inputString){
        byte[] bytes = Base64.getDecoder().decode(inputString);
        if(bytes == null || bytes.length == 0){
            return null;
        }
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        ByteArrayInputStream in = new ByteArrayInputStream(bytes);
        try{
            InflaterInputStream inflater = new InflaterInputStream(in);
            byte[] buffer = new byte[256];
            int n;
            while((n = inflater.read(buffer)) >= 0){
                out.write(buffer, 0, n);
            }
            return out.toString("utf-8");
        }catch (Exception e){
            throw new RuntimeException("DeflaterUnCompressError", e);
        }
    }


    public static byte[] compress(byte[] bytes){
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        DeflaterOutputStream deflaterOutputStream = new DeflaterOutputStream(out);
        try {
            deflaterOutputStream.write(bytes);
            deflaterOutputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return out.toByteArray();
    }

    public static byte[] unCompress(byte[] bytes){
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        ByteArrayInputStream in = new ByteArrayInputStream(bytes);
        try {
            InflaterInputStream inflater = new InflaterInputStream(in);
            byte[] buffer = new byte[256];
            int n;
            while((n = inflater.read(buffer)) >= 0){
                out.write(buffer, 0, n);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return out.toByteArray();
    }

    //deflate压缩
    public static String compress(String original){
        if(original == null || original.length() == 0){
            return null;
        }
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        DeflaterOutputStream deflater ;
        try{
            deflater = new DeflaterOutputStream(out);
            deflater.write(original.getBytes(StandardCharsets.UTF_8));
            deflater.close();
            return Base64.getEncoder().encodeToString(out.toByteArray());
        }catch (Exception e){
            throw new RuntimeException("DeflaterCompressError", e);
        }
    }


}

Gzip算法

package com.demo.rpc.compress;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.util.Base64;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;

public class GzipCompress {

    private static final String GZIP_ENCODE_UTF_8 = "UTF-8";

    //GZip解压缩
    public static String gzipUnCompress(String inputString){
        byte[] decode = Base64.getDecoder().decode(inputString);
        return unCompress(decode, GZIP_ENCODE_UTF_8);
    }

    public static String unCompress(byte[] bytes, String encoding){
        if(bytes == null || bytes.length == 0){
            return null;
        }
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        ByteArrayInputStream in = new ByteArrayInputStream(bytes);
        try{
            GZIPInputStream ungzip = new GZIPInputStream(in);
            byte[] buffer = new byte[256];
            int n;
            while((n = ungzip.read(buffer)) >= 0){
                out.write(buffer, 0, n);
            }
            return out.toString(encoding);
        }catch (Exception e){
            throw new RuntimeException("GzipUnCompressError", e);
        }
    }

    //Gzip压缩
    public static String gzipCompress(String original){
        return Base64.getEncoder().encodeToString(compress(original, GZIP_ENCODE_UTF_8));
    }

    public static byte[] compress(String str, String encoding){
        if(str == null || str.length() == 0){
            return null;
        }
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        GZIPOutputStream gzip ;
        try{
            gzip = new GZIPOutputStream(out);
            gzip.write(str.getBytes(encoding));
            gzip.close();
        }catch (Exception e){
            throw new RuntimeException("GzipCompressError", e);
        }
        return out.toByteArray();
    }


}

huffman算法

package com.demo.rpc.compress;

import java.io.*;
import java.util.*;

/**
 * @Date: 2020/9/24 15:14
 * @url:https://blog.csdn.net/qq_41966475/article/details/108550909?utm_medium=distribute.pc_relevant.none-task-blog-title-5&spm=1001.2101.3001.4242
 */
public class HuffmanCompress {

    //数据的解压
    public byte[] unCompress(Map<Byte, String> huffmanCodes, byte[] huffmanBytes) {
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < huffmanBytes.length; i++) {
            byte b = huffmanBytes[i];
            boolean flag = (i == huffmanBytes.length - 1);
            stringBuilder.append(byteToBitString(!flag, b));
        }
        System.out.print(stringBuilder);
        System.out.println();

        Map<String, Byte> map = new HashMap<>();
        for (Map.Entry<Byte, String> entry : huffmanCodes.entrySet()) {
            map.put(entry.getValue(), entry.getKey());
        }

        List<Byte> list = new ArrayList<>();
        for (int i = 0; i < stringBuilder.length(); ) {
            int count = 1;
            boolean flag = true;
            Byte b = null;

            while (flag) {
                String key = stringBuilder.substring(i, i + count);
                b = map.get(key);
                if (b == null) {
                    count++;
                } else {
                    flag = false;
                }
            }
            list.add(b);
            i += count;
        }
        byte[] b = new byte[list.size()];
        for (int i = 0; i < b.length; i++) {
            b[i] = list.get(i);
        }
        return b;
    }

    //把压缩的byte数组中的十进制数转化为2进制数
    private String byteToBitString(boolean flag, byte b) {
        int temp = b;
        if (flag) {
            temp |= 256;
        }
        String str = Integer.toBinaryString(temp);
        if (flag) {
            return str.substring(str.length() - 8);
        } else {
            return str;
        }
    }

    //封装压缩操作
    public byte[] compress(Map<Byte, String> huffmanCodes , byte[] bytes) {
        List<Node> nodes = getNodes(bytes);

        Node root = creatHuffmanTree(nodes);

        getCodes(huffmanCodes, root);

        byte[] huffmanCodeBytes = zip(bytes, huffmanCodes);

        return huffmanCodeBytes;
    }

    /**
     * @param bytes        原始的字符串对应的数组
     * @param huffmanCodes 生成的哈夫曼树编码map
     * @return 返回哈夫曼编码处理后的byte[]
     */
    private byte[] zip(byte[] bytes, Map<Byte, String> huffmanCodes) {
        StringBuilder builder = new StringBuilder();

        for (byte b : bytes) {
            builder.append(huffmanCodes.get(b));
        }

        int len;
        if (builder.length() % 8 == 0) {
            len = builder.length() / 8;
        } else {
            len = builder.length() / 8 + 1;
        }

        byte[] huffmanCodeBytes = new byte[len];
        int index = 0;
        for (int i = 0; i < builder.length(); i = i + 8) {
            String strByte;
            if (i + 8 > builder.length()) {
                strByte = builder.substring(i);
            } else {
                strByte = builder.substring(i, i + 8);
            }
            huffmanCodeBytes[index] = (byte) Integer.parseInt(strByte, 2);
            index++;
        }
        return huffmanCodeBytes;
    }

//    Map<Byte, String> huffmanCodes = new HashMap<>();
//
//    StringBuilder stringBuilder = new StringBuilder();

    private Map<Byte, String> getCodes(Map<Byte, String> huffmanCodes, Node root) {
        if (root == null) {
            return null;
        }
        getCodes(huffmanCodes, root.left, "0", new StringBuilder());
        getCodes(huffmanCodes, root.right, "1", new StringBuilder());
        return huffmanCodes;
    }

    /**
     * 将传入的node节点的所有叶子节点哈夫曼编码得到，并放入到huffmanCode集合中
     *
     * @param node          传入节点
     * @param code          路径，左0右1
     * @param stringBuilder 用于拼接路径
     */
    private void getCodes(Map<Byte, String> huffmanCodes, Node node, String code, StringBuilder stringBuilder) {
        StringBuilder builder = new StringBuilder(stringBuilder);
        builder.append(code);
        if (node != null) {
            if (node.data == null) {
                getCodes(huffmanCodes, node.left, "0", builder);
                getCodes(huffmanCodes, node.right, "1", builder);
            } else {
                huffmanCodes.put(node.data, builder.toString());
            }
        }
    }


    /**
     * @param bytes 接收字节数组
     * @return 返回的就算List
     */
    private List<Node> getNodes(byte[] bytes) {
        List<Node> nodes = new ArrayList<>();

        Map<Byte, Integer> counts = new HashMap<>();
        for (Byte b : bytes) {
            Integer count = counts.get(b);
            if (count == null) {
                counts.put(b, 1);
            } else {
                counts.put(b, count + 1);
            }
        }

        for (Map.Entry<Byte, Integer> entry : counts.entrySet()) {
            nodes.add(new Node(entry.getKey(), entry.getValue()));
        }
        return nodes;
    }

    //通过List创建哈夫曼树
    private Node creatHuffmanTree(List<Node> nodes) {
        while (nodes.size() > 1) {
            Collections.sort(nodes);
            Node leftNode = nodes.get(0);
            Node rightNode = nodes.get(1);
            Node parent = new Node(null, leftNode.weight + rightNode.weight);
            parent.left = leftNode;
            parent.right = rightNode;

            nodes.remove(leftNode);
            nodes.remove(rightNode);
            nodes.add(parent);
        }
        return nodes.get(0);
    }

}

//创建节点
class Node implements Comparable<Node> {
    Byte data;
    int weight;
    Node left;
    Node right;

    public Node(Byte data, int weight) {
        this.data = data;
        this.weight = weight;
    }

    @Override
    public int compareTo(Node o) {
        return this.weight - o.weight;
    }

    @Override
    public String toString() {
        return "Node{" +
                "data=" + data +
                ", weight=" + weight +
                '}';
    }
}

Lz4算法

依赖：

        <dependency>
            <groupId>org.lz4</groupId>
            <artifactId>lz4-java</artifactId>
            <version>1.7.1</version>
        </dependency>

Lz4算法java实现源码：

package com.demo.rpc.compress;

import net.jpountz.lz4.LZ4BlockInputStream;
import net.jpountz.lz4.LZ4BlockOutputStream;
import net.jpountz.lz4.LZ4Compressor;
import net.jpountz.lz4.LZ4Factory;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class Lz4Compress {

    //lz4解压缩
    public static String unCompress(String str){
        byte[] decode = Base64.getDecoder().decode(str.getBytes());
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try{
            LZ4BlockInputStream lzis = new LZ4BlockInputStream(
                    new ByteArrayInputStream(decode));
            int count;
            byte[] buffer = new byte[2048];
            while ((count = lzis.read(buffer)) != -1) {
                baos.write(buffer, 0, count);
            }
            lzis.close();
            return baos.toString("utf-8");
        }catch (Exception e){
            throw new RuntimeException("lz4UnCompressError", e);
        }
    }

    public static byte[] unCompress(byte[] bytes){
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try{
            LZ4BlockInputStream lzis = new LZ4BlockInputStream(
                    new ByteArrayInputStream(bytes));
            int count;
            byte[] buffer = new byte[2048];
            while ((count = lzis.read(buffer)) != -1) {
                baos.write(buffer, 0, count);
            }
            lzis.close();
            return baos.toByteArray();
        }catch (Exception e){
            throw new RuntimeException("lz4UnCompressError", e);
        }
    }


    //lz4压缩
    public static String compress(String str){
        LZ4Factory factory = LZ4Factory.fastestInstance();
        ByteArrayOutputStream byteOutput = new ByteArrayOutputStream();
        LZ4Compressor compressor = factory.fastCompressor();
        try{
            LZ4BlockOutputStream compressedOutput = new LZ4BlockOutputStream(
                    byteOutput, 2048, compressor);
            compressedOutput.write(str.getBytes(StandardCharsets.UTF_8));
            compressedOutput.close();
            return Base64.getEncoder().encodeToString(byteOutput.toByteArray());
        }catch (Exception e){
            throw new RuntimeException("lz4CompressError", e);
        }
    }

    public static byte[] compress(byte[] bytes){
        LZ4Factory factory = LZ4Factory.fastestInstance();
        ByteArrayOutputStream byteOutput = new ByteArrayOutputStream();
        LZ4Compressor compressor = factory.fastCompressor();
        try{
            LZ4BlockOutputStream compressedOutput = new LZ4BlockOutputStream(
                    byteOutput, 2048, compressor);
            compressedOutput.write(bytes);
            compressedOutput.close();
            return byteOutput.toByteArray();
        }catch (Exception e){
            throw new RuntimeException("lz4CompressError", e);
        }
    }
}

Lzo算法

依赖：

        <dependency>
            <groupId>org.anarres.lzo</groupId>
            <artifactId>lzo-core</artifactId>
            <version>1.0.6</version>
        </dependency>

Lzo算法java实现源码：

package com.demo.rpc.compress;

import org.anarres.lzo.*;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class LzoCompress {

    //lzo解压缩
    public static String unCompress(String str){
        LzoDecompressor decompressor = LzoLibrary.getInstance()
                .newDecompressor(LzoAlgorithm.LZO1X, null);
        try{
            ByteArrayOutputStream os = new ByteArrayOutputStream();
            ByteArrayInputStream is = new ByteArrayInputStream(Base64.getDecoder().decode(str.getBytes(StandardCharsets.UTF_8)));
            LzoInputStream lis = new LzoInputStream(is, decompressor);
            int count;
            byte[] buffer = new byte[256];
            while((count = lis.read(buffer)) != -1){
                os.write(buffer, 0, count);
            }
            return os.toString();
        }catch (Exception e){
            throw new RuntimeException("lzoUnCompressError", e);
        }
    }


    public static byte[] unCompress(byte[] bytes){
        LzoDecompressor decompressor = LzoLibrary.getInstance()
                .newDecompressor(LzoAlgorithm.LZO1X, null);
        try{
            ByteArrayOutputStream os = new ByteArrayOutputStream();
            ByteArrayInputStream is = new ByteArrayInputStream(bytes);
            LzoInputStream lis = new LzoInputStream(is, decompressor);
            int count;
            byte[] buffer = new byte[256];
            while((count = lis.read(buffer)) != -1){
                os.write(buffer, 0, count);
            }
            return os.toByteArray();
        }catch (Exception e){
            throw new RuntimeException("lzoUnCompressError", e);
        }
    }

    public static byte[] compress(byte[] bytes){
        LzoCompressor compressor = LzoLibrary.getInstance().newCompressor(
                LzoAlgorithm.LZO1X, null);
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        LzoOutputStream louts = new LzoOutputStream(os, compressor);
        try{
            louts.write(bytes);
            louts.close();
            return os.toByteArray();
        }catch (Exception e){
            throw new RuntimeException("LzoCompressError", e);
        }
    }

    public static String compress(String str){
        LzoCompressor compressor = LzoLibrary.getInstance().newCompressor(
                LzoAlgorithm.LZO1X, null);
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        LzoOutputStream louts = new LzoOutputStream(os, compressor);
        try{
            louts.write(str.getBytes(StandardCharsets.UTF_8));
            louts.close();
            return Base64.getEncoder().encodeToString(os.toByteArray());
        }catch (Exception e){
            throw new RuntimeException("LzoCompressError", e);
        }
    }


}

使用方式

package com.demo.rpc.compress;


import org.junit.Test;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class CompressorTest {

    String str = "http://www.baidu.com https://fanyi.baidu.com/ http://www.baidu.com ";

    @Test
    public void snappyCompress() throws IOException {
        SnappyCompressor snappyCompressor = new SnappyCompressor();
        byte[] compressed = snappyCompressor.compress(str.getBytes());
        System.out.println("压缩前数组大小: " + str.getBytes().length);
        System.out.println("压缩后数组大小：" + compressed.length);
        byte[] unCompressed = snappyCompressor.unCompress(compressed);
        System.out.println("原字符串：" + new String(unCompressed));
    }

    @Test
    public void gzipCompress(){
        String encode = "utf-8";
        byte[] compressed = GzipCompress.compress(str, encode);
        String unCompressed = GzipCompress.unCompress(compressed, encode);
        System.out.println("压缩前数组大小：" + str.getBytes().length);
        System.out.println("压缩后数组大小：" + compressed.length);
        System.out.println("原字符串：" + new String(unCompressed));
    }

    @Test
    public void deflateCompress(){
        byte[] compressed = DeflateCompress.compress(str.getBytes());
        byte[] unCompressed = DeflateCompress.unCompress(compressed);
        System.out.println("压缩前数组大小：" + str.getBytes().length);
        System.out.println("压缩后数组大小：" + compressed.length);
        System.out.println("原字符串：" + new String(unCompressed));
    }

    @Test
    public void huffmanCompress(){
        HuffmanCompress huffmanCompress = new HuffmanCompress();
        Map<Byte, String> huffmanCodec = new HashMap<>();
        byte[] compressed = huffmanCompress.compress(huffmanCodec, str.getBytes());
        byte[] unCompressed = huffmanCompress.unCompress(huffmanCodec, compressed);
        System.out.println("压缩前数组大小：" + str.getBytes().length);
        System.out.println("压缩后数组大小：" + compressed.length);
        System.out.println("原字符串：" + new String(unCompressed));
    }


    @Test
    public void lzoCompress(){
        byte[] compressed = LzoCompress.compress(str.getBytes());
        byte[] unCompressed = LzoCompress.unCompress(compressed);
        System.out.println("压缩前数组大小：" + str.getBytes().length);
        System.out.println("压缩后数组大小：" + compressed.length);
        System.out.println("原字符串：" + new String(unCompressed));
    }

    @Test
    public void lz4Compress(){
        byte[] compressed = Lz4Compress.compress(str.getBytes());
        byte[] unCompressed = Lz4Compress.unCompress(compressed);
        System.out.println("压缩前数组大小：" + str.getBytes().length);
        System.out.println("压缩后数组大小：" + compressed.length);
        System.out.println("原字符串：" + new String(unCompressed));
    }

}
成长的小牛233
关注
专栏目录
通用数据压缩算法简介
LEE的专栏
07-06 1255
通用数据压缩算法简介前言数据压缩技术始终是让我感觉到比较神秘的数学算法之一,而当我接触到其具体的算法时候，发现其原理是如此的简单，所以就写了这篇文件来谈谈自己的感想。但由于本文篇幅有限，就以只以一个最简单的LZ77算法作为例子来讲解。数据压缩技术其应用十分普遍
几种压缩算法
kaisuihu的专栏
04-02 4125
一、 行程长度压缩 　　原理是将一扫描行中的颜色值相同的相邻像素用一个计数值和那些像素的颜色值来代替。 例如:aaabccccccddeee，则可用3a1b6c2d3e来代替。对于拥有大面积，相同颜色区域的图像， 用RLE压缩方法非常有效。由RLE原理派生出许多具体行程压缩方法: 　　1.PCX行程压缩方法: 该算法实际上是位映射格式到压缩格式的转换算法，该算法对于连续 出现1次的字节
探索高效数据压缩：snappy-java 开源项目推荐
最新发布
gitblog_00459的博客
08-10 372
探索高效数据压缩：snappy-java 开源项目推荐 snappy-javaSnappy compressor/decompressor for Java项目地址:https://gitcode.com/gh_mirrors/sn/snappy-java 在数据处理和存储的世界中，高效的压缩算法是提升性能和节省资源的关键。今天，我们将深入介绍一个在Java领域广受好评的开源项目——snappy...
几个常见的压缩算法
Welcome Friends~
07-24 1577
（一） 字典算法字典算法是最为简单的压缩算法之一。它是把文本中出现频率比较多的单词或词汇组合做成一个对应的字典列表，并用特殊代码来表示这个单词或词汇。例如：有字典列表：00=Chinese01=People02=China源文本：I am a Chinese people,I am from China 压缩后的编码为：I am a 00 01,I am from 02。压缩编码后的长度显著缩小，
常见压缩算法
高阶近似的博客
08-05 4242
压缩算法 基础 压缩类型 逻辑压缩(Logical Compression)和物理压缩(Physical Compression) 逻辑压缩：根据数据的含义来压缩，只适用于特定的领域，比如录音 物理压缩：只需要知道数据的比特位，不需要知道这些比特的含义 有损压缩(Lossy Compression)和无损压缩(Lossless Compression) 有损压缩：可以实现更好的压缩比例，但是解码是近似的，确切的源文本(Source text)无法还原。 无损压缩：可以准确还原源文本 本文聚焦phys
常用压缩算法
happylife1527的专栏
09-21 1467
http://blog.csdn.net/caiguowu/article/details/6926103 本文是对常用算法的一些学习总结，当然，网上资源多，在学习过程中，很多有价值的资料也都来自网上一些牛B叉叉的人物，所以文中很多内容，在网上可能也都搜索的到。         我呢，其实，只是把他们强凑在一起而已 。这样，大家学习起来，也       （一） 字典算法
各种压缩算法C++实现
01-18
本话题主要探讨了四种常见的压缩算法的C++实现：哈夫曼编码（包括非自适应和自适应）、LZW编码以及算术编码。这些算法都是为了减少原始数据的存储空间，提高效率，同时保持数据的完整性。 首先，哈夫曼编码是一种...
MD5压缩算法_MD5压缩算法_
09-29
在描述中提到的"MD5压缩算法源码 BCB 工程 + 源码"，可能是指包含了一个用Borland C++ Builder (BCB)开发环境编写的MD5实现项目。BCB是 Borland 公司推出的一种C++集成开发环境，它提供了一套用于创建Windows桌面...
文本压缩算法的学习和实践毕业论文.docx
08-09
"文本压缩算法的学习和实践毕业论文.docx" 本文阐述了四种比较经典的编码算法（算术、游程、字典、huffman）的基本原理和实现过程，并实现对应算法对不同的文本进行编码，比较压缩效率的高低和时间的长短。 压缩...
pcm.rar_pcm 压缩_pcm 压缩算法_pcm压缩_pcm压缩算法_pcm算法代码
09-24
PCM压缩算法则是在保持数据精度的同时，通过各种技术减少音频数据的存储空间，使得文件更易于传输和存储。 在给定的“pcm.rar”压缩包中，包含两个文件：“ae_pcm.c”和“www.pudn.com.txt”。其中，“ae_pcm.c”很...
易语言源码易语言lzss压缩算法源码.rar
02-17
本压缩包文件包含的是易语言lzss压缩算法的源码，这是一种常见的数据压缩算法，尤其适用于对磁盘空间有限或传输速度要求较高的场景。 LZSS（Lempel-Ziv-Storer-Szymanski）压缩算法是基于字典的无损压缩方法，由...
几种常用的压缩算法
03-30
几种常用的压缩算法 本程序包含以下功能： 1、 Arithmetic coding 2、 Huffman coding 3、 LZ77 coding 4、 LZ78 coding 5、 LZW 6、 RLE 7、 DCT 8、 Furie transform
几种常见压缩算法
06-05
几种常见的压缩算法介绍，包括算法原理和编程实现思路，适合初次接触压缩算法的人
一种高效的通用数据压缩算法
02-21
一种高效的通用数据压缩算法,pdf格式的。
图片压缩算法
09-25
android士大夫撒啊摔 阿斯顿发生水淀粉阿斯顿发阿斯顿发生暗示法sad 发生的奥迪发生的发送短发 阿斯顿发安抚阿斯顿发
几种压缩算法原理介绍
热门推荐
书山有路勤为径，学海无涯苦作舟
01-06 1万+
1.   RLERLE又叫Run Length Encoding，是一个针对无损压缩的非常简单的算法。它用重复字节和重复的次数来简单描述来代替重复的字节。尽管简单并且对于通常的压缩非常低效，但它有的时候却非常有用（例如，JPEG就使用它）。1.1. 原理图2.1显示了一个如何使用RLE算法来对一个数据流编码的例子，其中出现六次的符号‘93’已经用3个字节来代替：一个标记字节（‘0’在本例中）重复的
压缩算法
blade2001的专栏
12-03 4161
压缩算法一、 行程长度压缩 　　原理是将一扫描行中的颜色值相同的相邻像素用一个计数值和那些像素的颜色值来代替。例如:aaabccccccddeee，则可用3a1b6c2d3e来代替。对于拥有大面积，相同颜色区域的图像，用RLE压缩方法非常有效。由RLE原理派生出许多具体行程压缩方法: 　　1.PCX行程压缩方法: 该算法实际上是位映射格式到压缩格式的转换算法，该算法对于连续出现1次的字节Ch，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值