java中常用的压缩与解压

最新推荐文章于 2024-08-19 18:42:30 发布
最新推荐文章于 2024-08-19 18:42:30 发布
阅读量1.6k 收藏 5
点赞数 3
分类专栏： 编程
随意转载。
本文链接：https://blog.csdn.net/dengjili/article/details/86554012
版权

目录

各算法测试结果比较

压缩时间包括对象创建,压缩，解压过程，这里没有移除调对象创建时间，可根据代码多文件大小进行多次测试，这里仅仅是举例

算法名称压缩前文件大小压缩后文件大小压缩时间
deflate1024 * 1077071
gzip1024 * 1077192
bzip21024 * 101029344
lzo1024 * 10102931
lz41024 * 1010324294
snappy1024 * 101024577

抽象接口

/**
 * 数据压缩和解压，提供顶层抽象，执行具体实现
 * <ul>
 * <li>deflate</li>
 * <li>gzip</li>
 * <li>bzip2</li>
 * <li>lzo</li>
 * <li>lz4</li>
 * <li>snappy</li>
 * </ul>
 */
public interface Compress {

	/**
	 * 数据压缩
	 */
	byte[] compress(byte[] data) throws IOException;

	/**
	 * 数据解压
	 */
	byte[] uncompress(byte[] data) throws IOException;

}

具体的算法实现

deflate
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.zip.DataFormatException;
import java.util.zip.Deflater;
import java.util.zip.Inflater;

import priv.dengjl.compress.Compress;

/**
 * deflater压缩,基于java jdk
 * 
 * <p>继承关系,基于FilterOutputStream的包装流</p>
 * <pre>
 * java.lang.Object
 *   java.io.OutputStream
 *     java.io.FilterOutputStream
 *       java.util.zip.DeflaterOutputStream
 * </pre>
 * 
 * @author it
 */
public class DeflaterCompress implements Compress {

	@Override
	public byte[] compress(byte[] data) throws IOException {
		// 构建压缩器
		Deflater compressor = new Deflater();
		compressor.setInput(data);
		compressor.finish();
		
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		byte[] buffer = new byte[4096];
		try {
			while (!compressor.finished()) {
				int compressLen = compressor.deflate(buffer);
				bos.write(buffer, 0, compressLen);
			}
		} finally {
			// 释放资源
			compressor.end();
		}
		
		return bos.toByteArray();
	}

	@Override
	public byte[] uncompress(byte[] data) throws IOException {
		// 构建解压器
		Inflater decompressor = new Inflater();
		decompressor.setInput(data);
		
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		byte[] buffer = new byte[4096];
		try {
			while (!decompressor.finished()) {
				int decompressLen = decompressor.inflate(buffer);
				bos.write(buffer, 0, decompressLen);
			}
		} catch (DataFormatException e) {
			throw new RuntimeException(e);
		} finally {
			// 释放资源
			decompressor.end();
		}
		
		return bos.toByteArray();
	}
}
gzip
/**
 * gzip算法
 * 
 * <p>继承关系,基于DeflaterOutputStream的包装</p>
 * <pre>
 * java.lang.Object
 *   java.io.OutputStream
 *     java.io.FilterOutputStream
 *       java.util.zip.DeflaterOutputStream
 *         java.util.zip.GZIPOutputStream
 * </pre>
 * 
 * @author it
 */
public class GzipCompress implements Compress {

	@Override
	public byte[] compress(byte[] data) throws IOException {
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		// 通过GZIPOutputStream增值包装流进行压缩
		try (GZIPOutputStream gzip = new GZIPOutputStream(out)) {
			gzip.write(data);
		}
		return out.toByteArray();
	}

	@Override
	public byte[] uncompress(byte[] data) throws IOException {
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		byte[] buffer = new byte[4096];
		int len = 0;
		
		// 通过GZIPInputStream增值包装流进行解压
		try (GZIPInputStream ungzip = new GZIPInputStream(new ByteArrayInputStream(data))){
			while ((len = ungzip.read(buffer)) > 0) {
				out.write(buffer, 0, len);
			}
		}
		return out.toByteArray();
	}
}
bzip2
/**
 * bzip2压缩依赖于apache commons-compress包
 * 
 */
public class Bzip2Compress implements Compress {

	@Override
	public byte[] compress(byte[] data) throws IOException {
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		// 通过BZip2CompressorOutputStream增值包装流进行压缩
		try (BZip2CompressorOutputStream bcos = new BZip2CompressorOutputStream(out)) {
			bcos.write(data);
		}
		return out.toByteArray();
	}

	@Override
	public byte[] uncompress(byte[] data) throws IOException {
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		byte[] buffer = new byte[4096];
		int len = 0;
		
		// 通过BZip2CompressorInputStream增值包装流进行解压
		try (BZip2CompressorInputStream unbzip = new BZip2CompressorInputStream(new ByteArrayInputStream(data))){
			while ((len = unbzip.read(buffer)) > 0) {
				out.write(buffer, 0, len);
			}
		}
		return out.toByteArray();
	}
}
lzo
/**
 * LZO是致力于解压速度的一种数据压缩算法，LZO是Lempel-Ziv-Oberhumer的缩写。这个算法是无损算法
 * 
 * 依赖于lzo-core包
 * 
 * @author it
 */
public class LzoCompress implements Compress {

	@Override
	public byte[] compress(byte[] data) throws IOException {
		LzoCompressor compressor = LzoLibrary.getInstance().newCompressor(LzoAlgorithm.LZO1X, null);
		ByteArrayOutputStream os = new ByteArrayOutputStream();
		// 通过LzoOutputStream增值包装流进行压缩
		try (LzoOutputStream cs = new LzoOutputStream(os, compressor)) {
			cs.write(data);
		}
		return os.toByteArray();
	}

	@Override
	public byte[] uncompress(byte[] data) throws IOException {
		LzoDecompressor decompressor = LzoLibrary.getInstance().newDecompressor(LzoAlgorithm.LZO1X, null);
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		byte[] buffer = new byte[4096];
		int len = 0;
		
		// 通过LzoInputStream增值包装流进行解压
		try (LzoInputStream us = new LzoInputStream(new ByteArrayInputStream(data), decompressor)) {
			while ((len = us.read(buffer)) != -1) {
				baos.write(buffer, 0, len);
			}
		}
		return baos.toByteArray();
	}
}
lz4
/**
 * LZ4是一种无损数据压缩算法，着重于压缩和解压缩速度
 * 
 * 依赖于lz4包
 * 
 * @author it
 */
public class Lz4Compress implements Compress {

	@Override
	public byte[] compress(byte[] data) throws IOException {
		LZ4Compressor compressor = LZ4Factory.fastestInstance().fastCompressor();
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		// 通过LZ4BlockOutputStream增值包装流进行压缩
		try (LZ4BlockOutputStream lz4Output = new LZ4BlockOutputStream(baos, 4096, compressor)) {
			lz4Output.write(data);
		}
		return baos.toByteArray();
	}

	@Override
	public byte[] uncompress(byte[] data) throws IOException {
		LZ4FastDecompressor decompresser = LZ4Factory.fastestInstance().fastDecompressor();
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		byte[] buffer = new byte[4096];
		int len = 0;
		
		// 通过LZ4BlockInputStream增值包装流进行解压
		try (LZ4BlockInputStream lzis = new LZ4BlockInputStream(new ByteArrayInputStream(data), decompresser)) {
			while ((len = lzis.read(buffer)) != -1) {
				baos.write(buffer, 0, len);
			}
		}
		return baos.toByteArray();
	}

}
snappy
**
 * Snappy（以前称Zippy）是Google基于LZ77的思路用C++语言编写的快速数据压缩与解压程序库，
 * 并在2011年开源。它的目标并非最大压缩率或与其他压缩程序库的兼容性，而是非常高的速度和合理的压缩率
 * 
 * 依赖于snappy-java包
 * 
 * @author it
 */
public class SnappyCompress implements Compress {

	@Override
	public byte[] compress(byte[] data) throws IOException {
		return Snappy.compress(data);
	}

	@Override
	public byte[] uncompress(byte[] data) throws IOException {
		return Snappy.uncompress(data);
	}

}

测试代码

对象生成辅助类
public enum CompressUtil {
	DEFLATER {
		Compress compress = new DeflaterCompress();

		public byte[] compress(byte[] data) throws IOException {
			return compress.compress(data);
		}

		public byte[] uncompress(byte[] data) throws IOException {
			return compress.uncompress(data);
		}
	},
	BZIP2 {
		Compress compress = new LzoCompress();

		public byte[] compress(byte[] data) throws IOException {
			return compress.compress(data);
		}

		public byte[] uncompress(byte[] data) throws IOException {
			return compress.uncompress(data);
		}
	},
	GZIP {
		Compress compress = new GzipCompress();

		public byte[] compress(byte[] data) throws IOException {
			return compress.compress(data);
		}

		public byte[] uncompress(byte[] data) throws IOException {
			return compress.uncompress(data);
		}
	},
	LZ4 {
		Compress compress = new Lz4Compress();

		public byte[] compress(byte[] data) throws IOException {
			return compress.compress(data);
		}

		public byte[] uncompress(byte[] data) throws IOException {
			return compress.uncompress(data);
		}
	},
	LZO {
		Compress compress = new LzoCompress();

		public byte[] compress(byte[] data) throws IOException {
			return compress.compress(data);
		}

		public byte[] uncompress(byte[] data) throws IOException {
			return compress.uncompress(data);
		}
	},
	SNAPPY {
		Compress compress = new SnappyCompress();

		public byte[] compress(byte[] data) throws IOException {
			return compress.compress(data);
		}

		public byte[] uncompress(byte[] data) throws IOException {
			return compress.uncompress(data);
		}
	};

	public byte[] compress(byte[] data) throws IOException {
		throw new AbstractMethodError();
	}

	public byte[] uncompress(byte[] data) throws IOException {
		throw new AbstractMethodError();
	}
}
测试类

CompressTest

public class CompressTest {

	public static final String allChar = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

	public static String generateString(int length) {
		StringBuffer sb = new StringBuffer();
		Random random = new Random();
		for (int i = 0; i < length; i++) {
			sb.append(allChar.charAt(random.nextInt(allChar.length())));
		}

		return sb.toString();
	}

	public static void main(String[] args) throws IOException {
		String data = generateString(1024 * 1000);
		// System.out.println("压缩前数据内容：" + data);
		byte[] dataBytes = data.getBytes();
		System.out.println("压缩前数据大小：" + dataBytes.length);
		
		CompressUtil[] values = CompressUtil.values();
		for (CompressUtil compressUtil : values) {
			System.out.println("===================: " + compressUtil.name());
			long start = System.currentTimeMillis();
			byte[] resultBytes = compressUtil.compress(dataBytes);
			System.out.println("压缩后数据大小:" + resultBytes.length);

			byte[] uncompressBytes = compressUtil.uncompress(resultBytes);
			System.out.println("解压后数据大小：" + uncompressBytes.length);
			String result = new String(uncompressBytes);
			// System.out.println("解压后数据内容：" + result);
			System.out.println("压缩时间(ms)：" + (System.currentTimeMillis() - start));
			System.out.println("===================: " + compressUtil.name());
			System.out.println();
		}
	}

}

测试结果

压缩前数据大小：1024000
===================: DEFLATER
压缩后数据大小:770121
解压后数据大小：1024000
压缩时间(ms)：69
===================: DEFLATER

===================: BZIP2
压缩后数据大小:1028208
解压后数据大小：1024000
压缩时间(ms)：76
===================: BZIP2

===================: GZIP
压缩后数据大小:770133
解压后数据大小：1024000
压缩时间(ms)：74
===================: GZIP

===================: LZ4
压缩后数据大小:1029271
解压后数据大小：1024000
压缩时间(ms)：300
===================: LZ4

===================: LZO
压缩后数据大小:1028208
解压后数据大小：1024000
压缩时间(ms)：8
===================: LZO

===================: SNAPPY
压缩后数据大小:1024051
解压后数据大小：1024000
压缩时间(ms)：74
===================: SNAPPY

公共代码重构

抽象基类AbstractCompress
/**
 * 重构gzip、bzip2、lz4、lzo重复代码
 * 
 * @author it
 */
public abstract class AbstractCompress implements Compress {
	
	// 构建模板方法
	protected abstract OutputStream createOutputStream(OutputStream output) throws IOException;
	protected abstract InputStream createInputStream(InputStream input) throws IOException;
	
	@Override
	public byte[] compress(byte[] data) throws IOException {
		ByteArrayOutputStream os = new ByteArrayOutputStream();
		try (OutputStream cs = createOutputStream(os)) {
			cs.write(data);
		}
		return os.toByteArray();
	}

	@Override
	public byte[] uncompress(byte[] data) throws IOException {
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		byte[] buffer = new byte[4096];
		int len = 0;
		
		try (InputStream us = createInputStream(new ByteArrayInputStream(data))) {
			while ((len = us.read(buffer)) != -1) {
				baos.write(buffer, 0, len);
			}
		}
		return baos.toByteArray();
	}
}
重构后Bzip2Compress如下
/**
 * bzip2压缩依赖于apache commons-compress包
 * 
 */
public class Bzip2Compress extends AbstractCompress {

	@Override
	protected OutputStream createOutputStream(OutputStream output) throws IOException {
		return new BZip2CompressorOutputStream(output);
	}

	@Override
	protected InputStream createInputStream(InputStream input) throws IOException {
		return new BZip2CompressorInputStream(input);
	}
}
其他

详见github，这里不再给出

项目地址

详见github项目：https://github.com/dengjili/java-compress

dengjili
关注
专栏目录
java应用org.xerial.snappy.Snappy实现数据压缩、解压缩，并对比三种压缩方式
weixin_44219085的博客
03-11 3996
一、导包 坐标： <dependency> <groupId>org.xerial.snappy</groupId> <artifactId>snappy-java</artifactId> <version>1.1.2.4</version> </dependency> 也可以去仓库...
java lzma解压_lzma-java
weixin_34175388的博客
02-24 326
相关开源项目DWR NetBeans plugin:DWR NetBeans pluginCapivara:Capivara是一个文件同步(FileSync)管理器,支持SFTP与FTP服务器.纯Java开发,支持Linux与Windows系统.Jeppers:Jeppers是一个基于Web的Java电子表格.它同时也提供一个用在Swing应用程序的LGPL Grid组件.GWTChismes:G...
snappy-java:Java的Snappy CompressorDecompressor
04-13
snappy-java snappy-java是snappy的Java端口， 是Google开发的快速C ++压缩器/解压缩器。 特征 快速压缩/解压缩，速度约200〜400MB /秒。 减少内存使用。 默认情况下，SnappyOutputStream仅使用32KB +。 基于JNI的实现可实现与本机C ++版本相当的性能。 尽管snappy-java使用JNI，但可以将其安全地与多个类加载器（例如Tomcat等）一起使用。 Java基本数组（ float[] ， double[] ， int[] ， short[] ， long[]等的压缩/解压缩） 为了提高这些数组的压缩率，可以在压缩之前使用快速的数据重排实现（ ） 可跨各种操作系统移植； Snappy-java包含为Window / Mac / Linux等构建的本机库。snappy-java根据您的计算机环境（看起来是
Snappy-java 解压文件
07-06 2839
snappy-java-1.1.2.6.jar 版本用的这个 public static JSONArray decompress() { List list = new ArrayList(); try { byte[] contents = Files.toByteArray(new File( “F:/spz/20161028145900.9.ttr.pack.spz”));
如何在Java中实现高效的压缩与解压算法：从Zlib到LZ4
最新发布
微赚淘客系统开发者博客
08-19 1204
本文将深入探讨如何在Java中实现高效的压缩与解压算法，包括Zlib和LZ4的使用示例、优缺点对比以及应用场景。在Java中实现高效的压缩与解压算法时，Zlib和LZ4是两个常用的选择。Zlib提供了合理的压缩比和较快的解压速度，而LZ4则以其极快的压缩和解压速度而著称。根据应用的需求选择合适的算法，可以有效地提升数据处理的效率和性能。选择经过广泛测试和优化的库，如LZ4和Zlib，可以帮助提高系统的稳定性和性能。LZ4是一种快速压缩算法，旨在提供非常高的压缩和解压速度，同时保持较好的压缩比。
Java压缩之LZW算法字典压缩与解压讲解
08-26
LZW算法是一种常用的字典压缩算法，在Java中可以用于实现文件压缩和解压。下面是关于Java压缩之LZW算法字典压缩与解压讲解的知识点总结： 一、压缩过程 在压缩过程中，首先将0-255个ASCLL码与对应的数字存入哈希表...
LZ78算法实现对任意字符串的压缩与解压
01-10
在Java程序中，你需要编写两个主要类：一个用于压缩，另一个用于解压。这两个类都需要维护字典状态，并按照上述步骤进行操作。同时，为了便于使用，可以设计一个主类来接收用户输入，调用压缩和解压类，并输出结果。...
java 操作Zip文件(压缩、解压、加密).zip
08-21
Java操作Zip文件主要涉及到对文件和目录的压缩与解压缩，以及在必要时对压缩文件进行加密处理。这里我们重点讨论使用两个库：`zip4j`和`Apache Ant`来实现这些功能。 1. **zip4j库**：`zip4j-1.3.2.jar`是一个用...
LZW.rar_LZW压缩java_lzw_lzw 文件压缩_压缩与解压缩_压缩解压
09-23
LZW（Lempel-Ziv-Welch）压缩算法是一种常用的无损数据压缩方法，尤其在文本和图像数据中表现出色。它通过构建一个字典来查找和编码重复的模式，从而达到压缩数据的目的。在Java中实现LZW压缩与解压缩涉及到以下几个...
snappy压缩，解压算法
07-07
google snappy 快速压缩算法，c语言版本 速度比zlib快10倍，内存占用大概多25%
snappy-java-1.1.2.jar
05-24
snappy-java-1.1.2.jar snappy-java-1.1.2.jar snappy-java-1.1.2.jar
实现java文件压缩与解压
12-21
好用的文件压缩与解压代码
java 压缩、解压
幽灵
02-27 120
1、压缩 package test; import java.io.*; import java.util.zip.*; public class ZipCompressing { private int k = 1; // 定义递归次数变量 private void zip(String zipFileName, File inputFile) throws Exc...
java 多重压缩下载_Java 多个文件压缩下载
weixin_35844772的博客
02-13 71
有时候会有多个附件一起下载的需求，这个时候最好就是打包下载了首先下面这段代码是正常的单个下载public void Download(@RequestParam("file_path") String file_path, HttpServletResponse response) {logger.info("try to download file, the filePath : " + fi...
java 压缩文件 解压缩文件
albert_lz的专栏
10-11 687
import java.io.BufferedInputStream;import java.io.BufferedOutputStream;import java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;import java.io.File;import java.io.FileFilter;import jav
android 和RxJava配合使用的两个图片压缩框架LuBan、Compressor
2401_84912209的博客
05-10 1718
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此我收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点！
java的方法decompress_Java LZ4SafeDecompressor.decompress方法代码示例
weixin_31999597的博客
02-16 655
import net.jpountz.lz4.LZ4SafeDecompressor; //导入方法依赖的package包/类public static void main(String[] args) throws IOException {LZ4Factory factory = LZ4Factory.fastestInstance();byte[] data = "Compressors a...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值