Java压缩技术

破晓 · 发表于 2015-1-11 13:16:25

Java压缩技术（一） ZLib

应好友需要，整理一下Java的压缩算法，先从ZLib开始。

有关ZLib可参见官方主页 http://www.zlib.net/
ZLib可以简单的理解为压缩/解压缩算法，它与ZIP、RAR等归档算法有所不同，与bzip2比较接近。

压缩工具代码如下：

/**
* 2009-9-9
*/
package org.zlex.commons.io;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.zip.Deflater;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.Inflater;
import java.util.zip.InflaterInputStream;
/**
* ZLib压缩工具
*
* @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>
* @version 1.0
* @since 1.0
*/
public abstract class ZLibUtils {
/**
* 压缩
*
* @param data
* 待压缩数据
* @return byte[] 压缩后的数据
*/
public static byte[] compress(byte[] data) {
byte[] output = new byte[0];
Deflater compresser = new Deflater();
compresser.reset();
compresser.setInput(data);
compresser.finish();
ByteArrayOutputStream bos = new ByteArrayOutputStream(data.length);
try {
byte[] buf = new byte[1024];
while (!compresser.finished()) {
int i = compresser.deflate(buf);
bos.write(buf, 0, i);
}
output = bos.toByteArray();
} catch (Exception e) {
output = data;
e.printStackTrace();
} finally {
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
compresser.end();
return output;
}
/**
* 压缩
*
* @param data
* 待压缩数据
*
* @param os
* 输出流
*/
public static void compress(byte[] data, OutputStream os) {
DeflaterOutputStream dos = new DeflaterOutputStream(os);
try {
dos.write(data, 0, data.length);
dos.finish();
dos.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 解压缩
*
* @param data
* 待压缩的数据
* @return byte[] 解压缩后的数据
*/
public static byte[] decompress(byte[] data) {
byte[] output = new byte[0];
Inflater decompresser = new Inflater();
decompresser.reset();
decompresser.setInput(data);
ByteArrayOutputStream o = new ByteArrayOutputStream(data.length);
try {
byte[] buf = new byte[1024];
while (!decompresser.finished()) {
int i = decompresser.inflate(buf);
o.write(buf, 0, i);
}
output = o.toByteArray();
} catch (Exception e) {
output = data;
e.printStackTrace();
} finally {
try {
o.close();
} catch (IOException e) {
e.printStackTrace();
}
}
decompresser.end();
return output;
}
/**
* 解压缩
*
* @param is
* 输入流
* @return byte[] 解压缩后的数据
*/
public static byte[] decompress(InputStream is) {
InflaterInputStream iis = new InflaterInputStream(is);
ByteArrayOutputStream o = new ByteArrayOutputStream(1024);
try {
int i = 1024;
byte[] buf = new byte[i];
while ((i = iis.read(buf, 0, i)) > 0) {
o.write(buf, 0, i);
}
} catch (IOException e) {
e.printStackTrace();
}
return o.toByteArray();
}
}

复制代码

测试用例代码如下：

/**
* 2009-9-9
*/
package org.zlex.commons.io;
import static org.junit.Assert.*;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import org.junit.Test;
/**
* ZLib压缩测试用例
*
* @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>
* @version 1.0
* @since 1.0
*/
public class ZLibUtilsTest {
@Test
public final void testBytes() {
System.err.println("字节压缩／解压缩测试");
String inputStr = "snowolf@zlex.org;dongliang@zlex.org;zlex.dongliang@zlex.org";
System.err.println("输入字符串:\t" + inputStr);
byte[] input = inputStr.getBytes();
System.err.println("输入字节长度:\t" + input.length);
byte[] data = ZLibUtils.compress(input);
System.err.println("压缩后字节长度:\t" + data.length);
byte[] output = ZLibUtils.decompress(data);
System.err.println("解压缩后字节长度:\t" + output.length);
String outputStr = new String(output);
System.err.println("输出字符串:\t" + outputStr);
assertEquals(inputStr, outputStr);
}
@Test
public final void testFile() {
String filename = "zlib";
File file = new File(filename);
System.err.println("文件压缩／解压缩测试");
String inputStr = "snowolf@zlex.org;dongliang@zlex.org;zlex.dongliang@zlex.org";
System.err.println("输入字符串:\t" + inputStr);
byte[] input = inputStr.getBytes();
System.err.println("输入字节长度:\t" + input.length);
try {
FileOutputStream fos = new FileOutputStream(file);
ZLibUtils.compress(input, fos);
fos.close();
System.err.println("压缩后字节长度:\t" + file.length());
} catch (Exception e) {
fail(e.getMessage());
}
byte[] output = null;
try {
FileInputStream fis = new FileInputStream(file);
output = ZLibUtils.decompress(fis);
fis.close();
} catch (Exception e) {
fail(e.getMessage());
}
System.err.println("解压缩后字节长度:\t" + output.length);
String outputStr = new String(output);
System.err.println("输出字符串:\t" + outputStr);
assertEquals(inputStr, outputStr);
}
}

复制代码

输入结果

字节压缩／解压缩测试
输入字符串: snowolf@zlex.org;dongliang@zlex.org;zlex.dongliang@zlex.org
输入字节长度: 59
压缩后字节长度: 39
解压缩后字节长度: 59
输出字符串: snowolf@zlex.org;dongliang@zlex.org;zlex.dongliang@zlex.org
文件压缩／解压缩测试
输入字符串: snowolf@zlex.org;dongliang@zlex.org;zlex.dongliang@zlex.org
输入字节长度: 59
压缩后字节长度: 39
解压缩后字节长度: 59
输出字符串: snowolf@zlex.org;dongliang@zlex.org;zlex.dongliang@zlex.org

复制代码

应该怎么计算呢？原数据长度59字节，压缩后39字节，大约是33％的压缩率！

ZLib压缩对大字节数据压缩，才能反映出压缩效果。
先占个位儿，回头细致整理！

本系列文章来自：http://snowolf.iteye.com/blog/465433

破晓 · 发表于 2015-1-11 13:19:20

Java压缩技术（二） ZIP压缩——Java原生实现

去年整理了一篇ZLib算法Java实现（Java压缩技术（一） ZLib），一直惦记却没时间补充。今天得空，整理一下ZIP的java原生实现。
看了几篇zip压缩算法的帖子，讲的算是比较细致了，但就是没有对应的解压缩实现，太惜败了！我就喜欢没事做总结，稍作整理，将其收纳！
查过相关资料后才知道，ZIP应该算作归档类的压缩算法，每一门学科都可深可浅！

闲言少叙，先说ZIP压缩。
zip压缩需要通过ZipOutputStream 执行write方法将压缩数据写到指定输出流中。
注意，这里应先使用CheckedOutputStream 指定文件校验算法。（通常使用CRC32算法）。代码如下所示：

CheckedOutputStream cos = new CheckedOutputStream(new FileOutputStream(destPath), new CRC32());
ZipOutputStream zos = new ZipOutputStream(cos);

复制代码

接下来，需要将待压缩文件以ZipEntry的方式追加到压缩文件中，如下所示：

/**
* 压缩包内文件名定义
*
* <pre>
* 如果有多级目录，那么这里就需要给出包含目录的文件名
* 如果用WinRAR打开压缩包，中文名将显示为乱码
* </pre>
*/
ZipEntry entry = new ZipEntry(dir + file.getName());
zos.putNextEntry(entry);

复制代码

ZipEntry就是压缩包中的每一个实体！
完成上述准备后，就可以执行压缩操作了。实际上，就是执行ZipOutputStream类的write方法，如下所示：

BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
file));
int count;
byte data[] = new byte[BUFFER];
while ((count = bis.read(data, 0, BUFFER)) != -1) {
zos.write(data, 0, count);
}
bis.close();

复制代码

当然，如果待添加的压缩项是一个目录。那么，需要通过递归的方式指定最终的压缩项。
如果要添加一个空目录，注意使用符号"/"(String PATH="/";)作为添加项名字结尾符！

递归构建目录压缩，代码如下：

/**
* 压缩
*
* @param srcFile
* 源路径
* @param zos
* ZipOutputStream
* @param basePath
* 压缩包内相对路径
* @throws Exception
*/
private static void compress(File srcFile, ZipOutputStream zos,
String basePath) throws Exception {
if (srcFile.isDirectory()) {
compressDir(srcFile, zos, basePath);
} else {
compressFile(srcFile, zos, basePath);
}
}
/**
* 压缩目录
*
* @param dir
* @param zos
* @param basePath
* @throws Exception
*/
private static void compressDir(File dir, ZipOutputStream zos,
String basePath) throws Exception {
File[] files = dir.listFiles();
// 构建空目录
if (files.length < 1) {
ZipEntry entry = new ZipEntry(basePath + dir.getName() + PATH);
zos.putNextEntry(entry);
zos.closeEntry();
}
for (File file : files) {
// 递归压缩
compress(file, zos, basePath + dir.getName() + PATH);
}
}

复制代码

x是一个空目录，用WinRAR打开后，可以看到这个目录下还有一个空文件名文件！

来个完整的压缩实现，代码如下所示：

/**
* 2010-4-12
*/
package org.zlex.commons.io;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.zip.CRC32;
import java.util.zip.CheckedInputStream;
import java.util.zip.CheckedOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;
/**
* ZIP压缩工具
*
* @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>
* @since 1.0
*/
public class ZipUtils {
public static final String EXT = ".zip";
private static final String BASE_DIR = "";
// 符号"/"用来作为目录标识判断符
private static final String PATH = "/";
private static final int BUFFER = 1024;
/**
* 压缩
*
* @param srcFile
* @throws Exception
*/
public static void compress(File srcFile) throws Exception {
String name = srcFile.getName();
String basePath = srcFile.getParent();
String destPath = basePath + name + EXT;
compress(srcFile, destPath);
}
/**
* 压缩
*
* @param srcFile
* 源路径
* @param destPath
* 目标路径
* @throws Exception
*/
public static void compress(File srcFile, File destFile) throws Exception {
// 对输出文件做CRC32校验
CheckedOutputStream cos = new CheckedOutputStream(new FileOutputStream(
destFile), new CRC32());
ZipOutputStream zos = new ZipOutputStream(cos);
compress(srcFile, zos, BASE_DIR);
zos.flush();
zos.close();
}
/**
* 压缩文件
*
* @param srcFile
* @param destPath
* @throws Exception
*/
public static void compress(File srcFile, String destPath) throws Exception {
compress(srcFile, new File(destPath));
}
/**
* 压缩
*
* @param srcFile
* 源路径
* @param zos
* ZipOutputStream
* @param basePath
* 压缩包内相对路径
* @throws Exception
*/
private static void compress(File srcFile, ZipOutputStream zos,
String basePath) throws Exception {
if (srcFile.isDirectory()) {
compressDir(srcFile, zos, basePath);
} else {
compressFile(srcFile, zos, basePath);
}
}
/**
* 压缩
*
* @param srcPath
* @throws Exception
*/
public static void compress(String srcPath) throws Exception {
File srcFile = new File(srcPath);
compress(srcFile);
}
/**
* 文件压缩
*
* @param srcPath
* 源文件路径
* @param destPath
* 目标文件路径
*
*/
public static void compress(String srcPath, String destPath)
throws Exception {
File srcFile = new File(srcPath);
compress(srcFile, destPath);
}
/**
* 压缩目录
*
* @param dir
* @param zos
* @param basePath
* @throws Exception
*/
private static void compressDir(File dir, ZipOutputStream zos,
String basePath) throws Exception {
File[] files = dir.listFiles();
// 构建空目录
if (files.length < 1) {
ZipEntry entry = new ZipEntry(basePath + dir.getName() + PATH);
zos.putNextEntry(entry);
zos.closeEntry();
}
for (File file : files) {
// 递归压缩
compress(file, zos, basePath + dir.getName() + PATH);
}
}
/**
* 文件压缩
*
* @param file
* 待压缩文件
* @param zos
* ZipOutputStream
* @param dir
* 压缩文件中的当前路径
* @throws Exception
*/
private static void compressFile(File file, ZipOutputStream zos, String dir)
throws Exception {
/**
* 压缩包内文件名定义
*
* <pre>
* 如果有多级目录，那么这里就需要给出包含目录的文件名
* 如果用WinRAR打开压缩包，中文名将显示为乱码
* </pre>
*/
ZipEntry entry = new ZipEntry(dir + file.getName());
zos.putNextEntry(entry);
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
file));
int count;
byte data[] = new byte[BUFFER];
while ((count = bis.read(data, 0, BUFFER)) != -1) {
zos.write(data, 0, count);
}
bis.close();
zos.closeEntry();
}
}

复制代码

来做个简单的测试：

import static org.junit.Assert.*;
import org.junit.Test;
/**
*
* @author 梁栋
* @version 1.0
* @since 1.0
*/
public class ZipUtilsTest {
/**
*
*/
@Test
public void test() throws Exception {
// 压缩文件
ZipUtils.compress("d:\\f.txt");
// 压缩目录
ZipUtils.compress("d:\\fd");
}
}

复制代码

现在用WinRAR打开看看，是不是效果几乎一致？

当然，上述代码有所不足之处主要是中文名称乱码问题。用java原生ZIP实现压缩后得到的压缩包，与系统的字符集不同，文件/目录名将出现乱码。这是所有归档压缩都会遇到的问题。对于这种问题，Commons Copress提供了解决方案！

对于解压缩，请关注后续内容！

破晓 · 发表于 2015-1-11 13:24:59

Java压缩技术（三） ZIP解压缩——Java原生实现

JavaEye的朋友跟我说：“你一口气把ZIP压缩和解压缩都写到一个帖子里，我看起来很累，不如分开好阅读”。ok，面向读者需求，我做调整，这里单说ZIP解压缩！
解压缩与压缩运作方式相反，原理大抵相同，由ZipInputStream通过read方法对数据解压，同时需要通过CheckedInputStream设置冗余校验码，如：

CheckedInputStream cis = new CheckedInputStream(new FileInputStream(
srcFile), new CRC32());
ZipInputStream zis = new ZipInputStream(cis);

复制代码

需要注意的是，在构建解压文件时，需要考虑目录的自动创建，这里通过递归方式逐层创建父目录，如下所示：

/**
* 文件探针
*
*
* 当父目录不存在时，创建目录！
*
*
* @param dirFile
*/
private static void fileProber(File dirFile) {
File parentFile = dirFile.getParentFile();
if (!parentFile.exists()) {
// 递归寻找上级目录
fileProber(parentFile);
parentFile.mkdir();
}
}

复制代码

在压缩的时候，我们是将一个一个文件作为压缩添加项（ZipEntry）添加至压缩包中，解压缩就要将一个一个压缩项从压缩包中提取出来，如下所示：

/**
* 文件解压缩
*
* @param destFile
* 目标文件
* @param zis
* ZipInputStream
* @throws Exception
*/
private static void decompress(File destFile, ZipInputStream zis)
throws Exception {
ZipEntry entry = null;
while ((entry = zis.getNextEntry()) != null) {
// 文件
String dir = destFile.getPath() + File.separator + entry.getName();
File dirFile = new File(dir);
// 文件检查
fileProber(dirFile);
if (entry.isDirectory()){
dirFile.mkdirs();
} else {
decompressFile(dirFile, zis);
}
zis.closeEntry();
}
}

复制代码

最核心的解压缩实现，其实与压缩实现非常相似，代码如下所示：

/**
* 文件解压缩
*
* @param destFile
* 目标文件
* @param zis
* ZipInputStream
* @throws Exception
*/
private static void decompressFile(File destFile, ZipInputStream zis)
throws Exception {
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(destFile));
int count;
byte data[] = new byte[BUFFER];
while ((count = zis.read(data, 0, BUFFER)) != -1) {
bos.write(data, 0, count);
}
bos.close();
}

复制代码

来个完整的解压缩实现，代码如下：

/**
* 2010-4-12
*/
package org.zlex.commons.io;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.zip.CRC32;
import java.util.zip.CheckedInputStream;
import java.util.zip.CheckedOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;
/**
* ZIP压缩工具
*
* @author 梁栋
* @since 1.0
*/
public class ZipUtils {
public static final String EXT = ".zip";
private static final String BASE_DIR = "";
private static final String PATH = File.separator;
private static final int BUFFER = 1024;
/**
* 文件解压缩
*
* @param srcPath
* 源文件路径
*
* @throws Exception
*/
public static void decompress(String srcPath) throws Exception {
File srcFile = new File(srcPath);
decompress(srcFile);
}
/**
* 解压缩
*
* @param srcFile
* @throws Exception
*/
public static void decompress(File srcFile) throws Exception {
String basePath = srcFile.getParent();
decompress(srcFile, basePath);
}
/**
* 解压缩
*
* @param srcFile
* @param destFile
* @throws Exception
*/
public static void decompress(File srcFile, File destFile) throws Exception {
CheckedInputStream cis = new CheckedInputStream(new FileInputStream(
srcFile), new CRC32());
ZipInputStream zis = new ZipInputStream(cis);
decompress(destFile, zis);
zis.close();
}
/**
* 解压缩
*
* @param srcFile
* @param destPath
* @throws Exception
*/
public static void decompress(File srcFile, String destPath)
throws Exception {
decompress(srcFile, new File(destPath));
}
/**
* 文件解压缩
*
* @param srcPath
* 源文件路径
* @param destPath
* 目标文件路径
* @throws Exception
*/
public static void decompress(String srcPath, String destPath)
throws Exception {
File srcFile = new File(srcPath);
decompress(srcFile, destPath);
}
/**
* 文件解压缩
*
* @param destFile
* 目标文件
* @param zis
* ZipInputStream
* @throws Exception
*/
private static void decompress(File destFile, ZipInputStream zis)
throws Exception {
ZipEntry entry = null;
while ((entry = zis.getNextEntry()) != null) {
// 文件
String dir = destFile.getPath() + File.separator + entry.getName();
File dirFile = new File(dir);
// 文件检查
fileProber(dirFile);
if (entry.isDirectory()) {
dirFile.mkdirs();
} else {
decompressFile(dirFile, zis);
}
zis.closeEntry();
}
}
/**
* 文件探针
*
*
* 当父目录不存在时，创建目录！
*
*
* @param dirFile
*/
private static void fileProber(File dirFile) {
File parentFile = dirFile.getParentFile();
if (!parentFile.exists()) {
// 递归寻找上级目录
fileProber(parentFile);
parentFile.mkdir();
}
}
/**
* 文件解压缩
*
* @param destFile
* 目标文件
* @param zis
* ZipInputStream
* @throws Exception
*/
private static void decompressFile(File destFile, ZipInputStream zis)
throws Exception {
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(destFile));
int count;
byte data[] = new byte[BUFFER];
while ((count = zis.read(data, 0, BUFFER)) != -1) {
bos.write(data, 0, count);
}
bos.close();
}
}

复制代码

其实，理解了ZIP的工作原理，这些代码看起来很好懂！

把刚才做的压缩文件再用上述代码解开看看，测试用例如下：

/**
* 2010-4-12
*/
package org.zlex.commons.io;
import static org.junit.Assert.*;
import org.junit.Test;
/**
*
* @author 梁栋
* @version 1.0
* @since 1.0
*/
public class ZipUtilsTest {
/**
*
*/
@Test
public void test() throws Exception {
// 解压到指定目录
ZipUtils.decompress("d:\\f.txt.zip", "d:\\ff");
// 解压到当前目录
ZipUtils.decompress("d:\\fd.zip");
}
}

复制代码

完整代码详见附件！

java原生的ZIP实现虽然在压缩时会因与系统字符集不符产生中文乱码，但在解压缩后，字符集即可恢复。

除了java原生的ZIP实现外，commons和ant也提供了相应的ZIP算法实现，有机会我再一一介绍！

破晓 · 发表于 2015-1-11 13:30:44

Java压缩技术（四） GZIP——Java原生实现

趁着头脑清楚，抓紧时间继续整理！
熟悉linux的朋友可能都用过文件压缩命令，譬如最为简单的gzip命令。

GZIP常常用在linxu环境下，是一种非常简单的压缩算法。在Java实现API中，它仅仅包含两个实现类：GZIPInputStream和GZIPOutputStream。
GZIPOutputStream类用于压缩
GZIPInputStream类用于解压缩

先说压缩实现，GZIPOutputStream只有一个方法用于压缩，就是带定长的write方法。简单调用如下文所示：

/**
* 数据压缩
*
* @param is
* @param os
* @throws Exception
*/
public static void compress(InputStream is, OutputStream os)
throws Exception {
GZIPOutputStream gos = new GZIPOutputStream(os);
int count;
byte data[] = new byte[BUFFER];
while ((count = is.read(data, 0, BUFFER)) != -1) {
gos.write(data, 0, count);
}
gos.finish();
gos.flush();
gos.close();
}

复制代码

记得完成操作后，调用finish方法和flush方法！

核心的压缩实现就这么多！

对于解压缩，GZIPInputStream也对应GZIPOutputStream提供了一个带定长的read方法。简单调用如下文所示：

/**
* 数据解压缩
*
* @param is
* @param os
* @throws Exception
*/
public static void decompress(InputStream is, OutputStream os)
throws Exception {
GZIPInputStream gis = new GZIPInputStream(is);
int count;
byte data[] = new byte[BUFFER];
while ((count = gis.read(data, 0, BUFFER)) != -1) {
os.write(data, 0, count);
}
gis.close();
}

复制代码

就这么简单！核心内容完毕！

顺便补充一下，在liunx下操作gzip命令

gzip file用于压缩，如gzip a.txt将得到文件a.txt.gz，同时删除文件a.txt!。
gzip -d file.gz用于解压缩，如gzip -d a.txt.gz将得到文件a.txt，同时删除文件a.txt.gz!。

根据这些特性，我补充了相应的文件操作实现，详见下文！

完整实现：

/**
* 2010-4-13
*/
package org.zlex.commons.io;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
/**
* GZIP工具
*
* @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>
* @since 1.0
*/
public abstract class GZipUtils {
public static final int BUFFER = 1024;
public static final String EXT = ".gz";
/**
* 数据压缩
*
* @param data
* @return
* @throws Exception
*/
public static byte[] compress(byte[] data) throws Exception {
ByteArrayInputStream bais = new ByteArrayInputStream(data);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
// 压缩
compress(bais, baos);
byte[] output = baos.toByteArray();
baos.flush();
baos.close();
bais.close();
return output;
}
/**
* 文件压缩
*
* @param file
* @throws Exception
*/
public static void compress(File file) throws Exception {
compress(file, true);
}
/**
* 文件压缩
*
* @param file
* @param delete
* 是否删除原始文件
* @throws Exception
*/
public static void compress(File file, boolean delete) throws Exception {
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(file.getPath() + EXT);
compress(fis, fos);
fis.close();
fos.flush();
fos.close();
if (delete) {
file.delete();
}
}
/**
* 数据压缩
*
* @param is
* @param os
* @throws Exception
*/
public static void compress(InputStream is, OutputStream os)
throws Exception {
GZIPOutputStream gos = new GZIPOutputStream(os);
int count;
byte data[] = new byte[BUFFER];
while ((count = is.read(data, 0, BUFFER)) != -1) {
gos.write(data, 0, count);
}
gos.finish();
gos.flush();
gos.close();
}
/**
* 文件压缩
*
* @param path
* @throws Exception
*/
public static void compress(String path) throws Exception {
compress(path, true);
}
/**
* 文件压缩
*
* @param path
* @param delete
* 是否删除原始文件
* @throws Exception
*/
public static void compress(String path, boolean delete) throws Exception {
File file = new File(path);
compress(file, delete);
}
/**
* 数据解压缩
*
* @param data
* @return
* @throws Exception
*/
public static byte[] decompress(byte[] data) throws Exception {
ByteArrayInputStream bais = new ByteArrayInputStream(data);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
// 解压缩
decompress(bais, baos);
data = baos.toByteArray();
baos.flush();
baos.close();
bais.close();
return data;
}
/**
* 文件解压缩
*
* @param file
* @throws Exception
*/
public static void decompress(File file) throws Exception {
decompress(file, true);
}
/**
* 文件解压缩
*
* @param file
* @param delete
* 是否删除原始文件
* @throws Exception
*/
public static void decompress(File file, boolean delete) throws Exception {
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(file.getPath().replace(EXT,
""));
decompress(fis, fos);
fis.close();
fos.flush();
fos.close();
if (delete) {
file.delete();
}
}
/**
* 数据解压缩
*
* @param is
* @param os
* @throws Exception
*/
public static void decompress(InputStream is, OutputStream os)
throws Exception {
GZIPInputStream gis = new GZIPInputStream(is);
int count;
byte data[] = new byte[BUFFER];
while ((count = gis.read(data, 0, BUFFER)) != -1) {
os.write(data, 0, count);
}
gis.close();
}
/**
* 文件解压缩
*
* @param path
* @throws Exception
*/
public static void decompress(String path) throws Exception {
decompress(path, true);
}
/**
* 文件解压缩
*
* @param path
* @param delete
* 是否删除原始文件
* @throws Exception
*/
public static void decompress(String path, boolean delete) throws Exception {
File file = new File(path);
decompress(file, delete);
}
}

复制代码

罗嗦了半天，到底行不行？
来个测试用例，测试用例如下所示：

/**
* 2010-4-13
*/
package org.zlex.commons.compress.compress;
import static org.junit.Assert.assertEquals;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import org.junit.Test;
/**
* @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>
* @since 1.0
*/
public class GZipUtilsTest {
private String inputStr = "zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org";
@Test
public final void testDataCompress() throws Exception {
System.err.println("原文:\t" + inputStr);
byte[] input = inputStr.getBytes();
System.err.println("长度:\t" + input.length);
byte[] data = GZipUtils.compress(input);
System.err.println("压缩后:\t");
System.err.println("长度:\t" + data.length);
byte[] output = GZipUtils.decompress(data);
String outputStr = new String(output);
System.err.println("解压缩后:\t" + outputStr);
System.err.println("长度:\t" + output.length);
assertEquals(inputStr, outputStr);
}
@Test
public final void testFileCompress() throws Exception {
FileOutputStream fos = new FileOutputStream("d:/f.txt");
fos.write(inputStr.getBytes());
fos.flush();
fos.close();
GZipUtils.compress("d:/f.txt", false);
GZipUtils.decompress("d:/f.txt.gz", false);
File file = new File("d:/f.txt");
FileInputStream fis = new FileInputStream(file);
DataInputStream dis = new DataInputStream(fis);
byte[] data = new byte[(int) file.length()];
dis.readFully(data);
fis.close();
String outputStr = new String(data);
assertEquals(inputStr, outputStr);
}
}

复制代码

结果如何？
先看testDataCompress()方法控制台输出结果。
控制台输出如下：

原文: zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org
长度: 52
压缩后:
长度: 45
解压缩后: zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org
长度: 52

复制代码

这里使用英文字符做测试，当输入字符串的字节数大于50左右时，压缩效果明显；如果这里使用中文压缩，可能当压缩上千字节时方能体现出压缩效果！
对于文件操作，朋友们可以自行实验，我代码里的实现是按照gzip命令来的！
举例来说：
压缩时，将文件a.txt压缩为a.txt.gz，同时删除文件a.txt。
解压缩时，将文件a.txt.gz解压缩为a.txt，同时删除文件a.txt.gz。

注意执行testFileCompress方法，查看产生的文件！你大可以放到linux上去做验证！

commons也提供了GZIP算法的实现，甚至更多种压缩算法（tar、bzip2等）的实现，有机会我将继续整理！

破晓 · 发表于 2015-1-11 13:35:06

Java压缩技术（五） GZIP相关——浏览器解析

昨天一篇GZIP相关实现引起大家的广泛关注，为一位朋友验证一下浏览器对gzip的支持情况，才有此文！

GZIP本身就是一种网络流压缩算法，而且应用相当广泛。如果网络访问过程中，其数据流较大，势必降低网络访问效率，此时就需要考虑使用压缩！当然，在浏览器与服务器的交互中，要考虑浏览器是否支持这些算法，以及服务器运行压缩所带来的负载。如果你关注浏览器上传的“Accept-Encoding”属性，你就能看明白这一点。

GZIP如何压缩，我这里就不废话了，不清楚的朋友请关注（Java压缩技术（四） GZIP——Java原生实现）
至于如何使得服务器支持gzip的流输出，关键点只有一行代码：

response.setHeader("Content-Encoding", "gzip");

复制代码

经过这项设置，浏览器就能够很好的作出响应！
先看FireFox，如图：

再看Opera，如图：

浏览器在打开该页面时，就可解压获得并展示其内容！
至于IE就惨了，愣是要求下载！可能缺少什么设置！（注意后续服务器配置！不是无解哦！）
你不信就这么简单？上代码！

/**
* 2010-4-14
*/
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.zip.GZIPOutputStream;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* GZip服务
*
* @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>
* @since 1.0
*/
public class GZipServlet extends HttpServlet {
private static final long serialVersionUID = -4811926975427533081L;
private static final String ENCODING = "UTF-8";
/**
* 压缩
*
* @param data
* @return
* @throws Exception
*/
private byte[] compress(byte[] data) throws Exception {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
// 压缩
GZIPOutputStream gos = new GZIPOutputStream(baos);
gos.write(data, 0, data.length);
gos.finish();
byte[] output = baos.toByteArray();
baos.flush();
baos.close();
return output;
}
/**
* @param request
* @param response
* @throws ServletException
* @throws IOException
*/
private void excute(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
byte[] data = "我是一个中国人！".getBytes(ENCODING);
try {
byte[] output = compress(data);
// 设置Content-Encoding，这是关键点！
response.setHeader("Content-Encoding", "gzip");
// 设置字符集
response.setCharacterEncoding(ENCODING);
// 设定输出流中内容长度
response.setContentLength(output.length);
OutputStream out = response.getOutputStream();
out.write(output);
out.flush();
out.close();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse
* response)
*/
protected void doGet(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
excute(request, response);
}
/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse
* response)
*/
protected void doPost(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
excute(request, response);
}
}

复制代码

其实，就这些内容！

当然，除了上述代码方式，针对于tomcat可以通过修改配置获得支持！

<Connector
port="8080"
protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="443"
URIEncoding="UTF-8"
compression="on"
noCompressionUserAgents="gozilla, traviata"
compressableMimeType="text/html,text/xml,text/javascript,text/css,text/plain,application/json"
/>

复制代码

说说配置细节：
compression="on" 开启压缩支持
noCompressionUserAgents="gozilla, traviata" 不压缩的内容
compressableMimeType="text/html,text/xml,text/javascript,text/css,text/plain,application/json" 压缩的类型

至于代码，你无需写一行代码！轻松获得服务器访问加速！ 并且IE也支持哦！

借网友经验，如下实现，轻松获得IE支持：

response.setContentType("text/plain;charset=utf-8");

复制代码

工程在我的附件里，请下载验证！

破晓 · 发表于 2015-1-11 13:39:02

Java压缩技术（六） BZIP2——Commons实现

想要把一整套算法都整理出来，的确是件非常老心费力的事情！但是如果一件事情不能有始有终，难免会有遗憾！索性，继续整理！

BZip2与GZip有什么渊源，我这里不深究。我要说的只是，这两种算法，你在linux下都可以找到相应的操作命令。

GZip
压缩
gzip <file> 将得到压缩文件<file>.gz，同时删除文件<file>
解压缩
gzip -d <file>.gz 将得到压缩文件<file>，同时删除文件<file>.gz

BZip2与之相当，几乎没有什么差别～～
BZip2
压缩
bzip2 <file> 将得到压缩文件<file>.bz2，同时删除文件<file>
解压缩
bzip2 -d <file>.bz2 将得到压缩文件<file>，同时删除文件<file>.bz2

除了命令不同外，几乎是一样的！

再说实现。GZIP是JDK自带的算法实现，但BZip2则不曾享受这个待遇。不过，强大的Apache坚决不会让这些个在Linux下如鱼得水的算法在Java世界中销声匿迹。Apache在Commons Compress中提供了相应的实现。同时，还包括众所周知的tar、cpio、zip等算法实现，其中最为丰富的当属zip实现了！

我继续依葫芦画瓢～～～
BZip2CompressorOutputStream类用于压缩
BZip2CompressorInputStream类用于解压缩

先说压缩实现，BZip2CompressorOutputStream只有一个方法用于压缩，就是带定长的write方法。简单调用如下文所示：

/**
* 数据压缩
*
* @param is
* @param os
* @throws Exception
*/
public static void compress(InputStream is, OutputStream os)
throws Exception {
BZip2CompressorOutputStream gos = new BZip2CompressorOutputStream(os);
int count;
byte data[] = new byte[BUFFER];
while ((count = is.read(data, 0, BUFFER)) != -1) {
gos.write(data, 0, count);
}
gos.finish();
gos.flush();
gos.close();
}

复制代码

与GZip实现有何差别？除了换掉了GZIPOutputStream没有任何差别。

解压缩就更不用说了，BZip2CompressorInputStream提供了一个带定长的read方法。简单调用如下文所示：

/**
* 数据解压缩
*
* @param is
* @param os
* @throws Exception
*/
public static void decompress(InputStream is, OutputStream os)
throws Exception {
BZip2CompressorInputStream gis = new BZip2CompressorInputStream(is);
int count;
byte data[] = new byte[BUFFER];
while ((count = gis.read(data, 0, BUFFER)) != -1) {
os.write(data, 0, count);
}
gis.close();
}

复制代码

嗯，没什么难度！
IT这行就是这样，只要你肯用心，能触类旁通，就能融会贯通！
给一个完整实现：

/**
* 2010-4-15
*/
package org.zlex.commons.compress.compress;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream;
import org.apache.commons.compress.compressors.bzip2.BZip2CompressorOutputStream;
/**
* BZip2工具
*
* @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>
* @since 1.0
*/
public abstract class BZip2Utils {
public static final int BUFFER = 1024;
public static final CharSequence EXT = ".bz2";
/**
* 数据压缩
*
* @param data
* @return
* @throws Exception
*/
public static byte[] compress(byte[] data) throws Exception {
ByteArrayInputStream bais = new ByteArrayInputStream(data);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
// 压缩
compress(bais, baos);
byte[] output = baos.toByteArray();
baos.flush();
baos.close();
bais.close();
return output;
}
/**
* 文件压缩
*
* @param file
* @throws Exception
*/
public static void compress(File file) throws Exception {
compress(file, true);
}
/**
* 文件压缩
*
* @param file
* @param delete
* 是否删除原始文件
* @throws Exception
*/
public static void compress(File file, boolean delete) throws Exception {
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(file.getPath() + EXT);
compress(fis, fos);
fis.close();
fos.flush();
fos.close();
if (delete) {
file.delete();
}
}
/**
* 数据压缩
*
* @param is
* @param os
* @throws Exception
*/
public static void compress(InputStream is, OutputStream os)
throws Exception {
BZip2CompressorOutputStream gos = new BZip2CompressorOutputStream(os);
int count;
byte data[] = new byte[BUFFER];
while ((count = is.read(data, 0, BUFFER)) != -1) {
gos.write(data, 0, count);
}
gos.finish();
gos.flush();
gos.close();
}
/**
* 文件压缩
*
* @param path
* @throws Exception
*/
public static void compress(String path) throws Exception {
compress(path, true);
}
/**
* 文件压缩
*
* @param path
* @param delete
* 是否删除原始文件
* @throws Exception
*/
public static void compress(String path, boolean delete) throws Exception {
File file = new File(path);
compress(file, delete);
}
/**
* 数据解压缩
*
* @param data
* @return
* @throws Exception
*/
public static byte[] decompress(byte[] data) throws Exception {
ByteArrayInputStream bais = new ByteArrayInputStream(data);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
// 解压缩
decompress(bais, baos);
data = baos.toByteArray();
baos.flush();
baos.close();
bais.close();
return data;
}
/**
* 文件解压缩
*
* @param file
* @throws Exception
*/
public static void decompress(File file) throws Exception {
decompress(file, true);
}
/**
* 文件解压缩
*
* @param file
* @param delete
* 是否删除原始文件
* @throws Exception
*/
public static void decompress(File file, boolean delete) throws Exception {
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(file.getPath().replace(EXT,
""));
decompress(fis, fos);
fis.close();
fos.flush();
fos.close();
if (delete) {
file.delete();
}
}
/**
* 数据解压缩
*
* @param is
* @param os
* @throws Exception
*/
public static void decompress(InputStream is, OutputStream os)
throws Exception {
BZip2CompressorInputStream gis = new BZip2CompressorInputStream(is);
int count;
byte data[] = new byte[BUFFER];
while ((count = gis.read(data, 0, BUFFER)) != -1) {
os.write(data, 0, count);
}
gis.close();
}
/**
* 文件解压缩
*
* @param path
* @throws Exception
*/
public static void decompress(String path) throws Exception {
decompress(path, true);
}
/**
* 文件解压缩
*
* @param path
* @param delete
* 是否删除原始文件
* @throws Exception
*/
public static void decompress(String path, boolean delete) throws Exception {
File file = new File(path);
decompress(file, delete);
}
}

复制代码

对应再来个测试用例，测试用例如下所示：

/**
* 2010-4-13
*/
package org.zlex.commons.compress.compress;
import static org.junit.Assert.assertEquals;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import org.junit.Test;
/**
* BZip2
*
* @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>
* @since 1.0
*/
public class BZip2UtilsTest {
private String inputStr = "zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org";
@Test
public final void testDataCompress() throws Exception {
byte[] input = inputStr.getBytes();
System.err.println("原文:\t" + inputStr);
System.err.println("长度:\t" + input.length);
byte[] data = BZip2Utils.compress(input);
System.err.println("压缩后:\t");
System.err.println("长度:\t" + data.length);
byte[] output = BZip2Utils.decompress(data);
String outputStr = new String(output);
System.err.println("解压缩后:\t" + outputStr);
System.err.println("长度:\t" + output.length);
assertEquals(inputStr, outputStr);
}
@Test
public final void testFileCompress() throws Exception {
FileOutputStream fos = new FileOutputStream("d:/f.txt");
fos.write(inputStr.getBytes());
fos.flush();
fos.close();
BZip2Utils.compress("d:/f.txt");
BZip2Utils.decompress("d:/f.txt.bz2");
File file = new File("d:/f.txt");
FileInputStream fis = new FileInputStream(file);
DataInputStream dis = new DataInputStream(fis);
byte[] data = new byte[(int) file.length()];
dis.readFully(data);
fis.close();
String outputStr = new String(data);
assertEquals(inputStr, outputStr);
}
}

复制代码

虽然，两种算法在代码实现上几乎没有什么差别，但在压缩上想要看到效果，还真让我费了点事！
控制台输出如下所示：

原文: zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org
长度: 529
压缩后:
长度: 76
解压缩后: zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org,zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org
长度: 529

复制代码

529字节-->76字节！
GZIP本身不需要太长的内容，经过压缩就能体现出压缩效果，而BZip2则需要压缩很长的内容时，才能体现其压缩效果，这说明BZip2更适合大数据压缩？！

Commons Compress不仅支持BZip2算法实现，同时也支持GZip算法实现。对于GZip算法实现，与Java原生实现基本上没有什么差别。其源代码分析，仅仅是做了简单的包装。
不过有必要提及的一点是，Commons Compress为压缩（GZip和BZip2）构建了压缩算法工厂类CompressorStreamFactory。通过这个类可以方便的构建GZip和BZip2的输入输出流，关键字分别为“gz”和“bzip2”。

GZip

// GzipCompressorInputStream
CompressorInputStream gzipIn = new CompressorStreamFactory()
.createCompressorInputStream("gz", is);
// GzipCompressorOutputStream
CompressorOutputStream gzipOut = new CompressorStreamFactory()
.createCompressorOutputStream("gz", os);

复制代码

BZip2

// BZip2CompressorInputStream
CompressorInputStream bzip2In = new CompressorStreamFactory()
.createCompressorInputStream("bzip2", is);
// BZip2CompressorOutputStream
CompressorOutputStream bzip2Out = new CompressorStreamFactory()
.createCompressorOutputStream("bzip2", os);

复制代码

GZip和BZip2在算法实现步骤上基本上没有什么差别，如果有必要统一，可按上述代码实现！

完整代码详见附件！

破晓 · 发表于 2015-1-11 13:46:42

Java压缩技术（七） TAR——Commons实现

在linux下，tar是一个归档命令。当然，如果配合gzip、bzip2就可以达到归档+压缩的效果！
我们通过tar获得归档压缩文件其实恰恰包含了归档和压缩两个操作，并且其操作次序也是先做归档操作，再做压缩操作！通常我们忽略了归档的概念，将归档压缩文件简称为压缩文件！～

顺便复习一遍linux命令：
tar cf <file.tar> <file>将由文件<file>创建名为<file.tar>归档文件，同时保留原文件。
tar xf <file.tar>将由归档文件<file.tar>创建名为<file>的文件/目录，同时保留原文件。

对于归档压缩，需分为gzip和bzip2，相应的linux为：
gzip
tar czf <file.tar.gz> <file>将由文件<file>创建名为<file.tar.gz>归档压缩文件，同时保留原文件。
tar xzf <file.tar.gz>将由归档压缩文件<file.tar.gz>创建名为<file>的文件/目录，同时保留原文件。

bzip2
tar cjf <file.tar.bz2> <file>将由文件<file>创建名为<file.tar.bz2>归档压缩文件，同时保留原文件。
tar xjf <file.tar.bz2>将由归档压缩文件<file.tar.bz2>创建名为<file>的文件/目录，同时保留原文件。

今天的主角是Apache Commons Compress下用于Tar操作的三元干将
TarArchiveEntry 类似于Java 原生的ZipEntry，可以理解为Tar归档添加项。
TarArchiveOutputStream Tar归档输出流，用于归档。
TarArchiveInputStream Tar归档输入流，用于解归档。

至于jar，其实现方式与tar非常接近，我就不在这里废话了！
JarArchiveEntry 类似于Java 原生的ZipEntry，可以理解为Jar归档添加项。
JarArchiveOutputStream Jar归档输出流，用于归档。
JarArchiveInputStream Jar归档输入流，用于解归档。

读过Java压缩技术（二）和Java压缩技术（三）会发现，其实Tar的实现与Java原生的Zip实现方式基本上没有差别！
先说归档，依旧需要考虑待归档的对象是文件还是目录：

/**
* 归档
*
* @param srcFile
* 源路径
* @param taos
* TarArchiveOutputStream
* @param basePath
* 归档包内相对路径
* @throws Exception
*/
private static void archive(File srcFile, TarArchiveOutputStream taos,
String basePath) throws Exception {
if (srcFile.isDirectory()) {
archiveDir(srcFile, taos, basePath);
} else {
archiveFile(srcFile, taos, basePath);
}
}

复制代码

对于目录，需要区分空目录和包含文件的目录。
如果是空目录，只要简单追加一个归档项（TarArchiveEntry）即可，但注意其名字的结尾需要使用"/"作为区分目录的标识符（String PATH = "/";）。
如果是带有子文件的目录，则需要对其迭代归档：

/**
* 目录归档
*
* @param dir
* @param taos
* TarArchiveOutputStream
* @param basePath
* @throws Exception
*/
private static void archiveDir(File dir, TarArchiveOutputStream taos,
String basePath) throws Exception {
File[] files = dir.listFiles();
if (files.length < 1) {
TarArchiveEntry entry = new TarArchiveEntry(basePath
+ dir.getName() + PATH);
taos.putArchiveEntry(entry);
taos.closeArchiveEntry();
}
for (File file : files) {
// 递归归档
archive(file, taos, basePath + dir.getName() + PATH);
}
}

复制代码

最后，来看归档操作：

/**
* 数据归档
*
* @param data
* 待归档数据
* @param path
* 归档数据的当前路径
* @param name
* 归档文件名
* @param taos
* TarArchiveOutputStream
* @throws Exception
*/
private static void archiveFile(File file, TarArchiveOutputStream taos,
String dir) throws Exception {
TarArchiveEntry entry = new TarArchiveEntry(dir + file.getName());
entry.setSize(file.length());
taos.putArchiveEntry(entry);
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
file));
int count;
byte data[] = new byte[BUFFER];
while ((count = bis.read(data, 0, BUFFER)) != -1) {
taos.write(data, 0, count);
}
bis.close();
taos.closeArchiveEntry();
}

复制代码

注意执行归档操作后，执行closeArchiveEntry()方法。
Tar解归档，与Zip解压相似，一样要遍历获得归档项：

/**
* 文件解归档
*
* @param destFile
* 目标文件
* @param tais
* ZipInputStream
* @throws Exception
*/
private static void dearchive(File destFile, TarArchiveInputStream tais)
throws Exception {
TarArchiveEntry entry = null;
while ((entry = tais.getNextTarEntry()) != null) {
// 文件
String dir = destFile.getPath() + File.separator + entry.getName();
File dirFile = new File(dir);
// 文件检查
fileProber(dirFile);
if (entry.isDirectory()) {
dirFile.mkdirs();
} else {
dearchiveFile(dirFile, tais);
}
}
}

复制代码

最后，进行解归档：

/**
* 文件解归档
*
* @param destFile
* 目标文件
* @param tais
* TarArchiveInputStream
* @throws Exception
*/
private static void dearchiveFile(File destFile, TarArchiveInputStream tais)
throws Exception {
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(destFile));
int count;
byte data[] = new byte[BUFFER];
while ((count = tais.read(data, 0, BUFFER)) != -1) {
bos.write(data, 0, count);
}
bos.close();
}

复制代码

文件探针用于构建父目录：

/**
* 文件探针
*
* <pre>
* 当父目录不存在时，创建目录！
* </pre>
*
* @param dirFile
*/
private static void fileProber(File dirFile) {
File parentFile = dirFile.getParentFile();
if (!parentFile.exists()) {
// 递归寻找上级目录
fileProber(parentFile);
parentFile.mkdir();
}
}

复制代码

给出完整实现：

/**
* 2010-4-20
*/
package org.zlex.commons.compress;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import org.apache.commons.compress.archivers.tar.TarArchiveEntry;
import org.apache.commons.compress.archivers.tar.TarArchiveOutputStream;
import org.apache.commons.compress.archivers.tar.TarArchiveInputStream;
/**
* TAR工具
*
* @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>
* @since 1.0
*/
public abstract class TarUtils {
private static final String BASE_DIR = "";
// 符号"/"用来作为目录标识判断符
private static final String PATH = "/";
private static final int BUFFER = 1024;
private static final String EXT = ".tar";
/**
* 归档
*
* @param srcPath
* @param destPath
* @throws Exception
*/
public static void archive(String srcPath, String destPath)
throws Exception {
File srcFile = new File(srcPath);
archive(srcFile, destPath);
}
/**
* 归档
*
* @param srcFile
* 源路径
* @param destPath
* 目标路径
* @throws Exception
*/
public static void archive(File srcFile, File destFile) throws Exception {
TarArchiveOutputStream taos = new TarArchiveOutputStream(
new FileOutputStream(destFile));
archive(srcFile, taos, BASE_DIR);
taos.flush();
taos.close();
}
/**
* 归档
*
* @param srcFile
* @throws Exception
*/
public static void archive(File srcFile) throws Exception {
String name = srcFile.getName();
String basePath = srcFile.getParent();
String destPath = basePath + name + EXT;
archive(srcFile, destPath);
}
/**
* 归档文件
*
* @param srcFile
* @param destPath
* @throws Exception
*/
public static void archive(File srcFile, String destPath) throws Exception {
archive(srcFile, new File(destPath));
}
/**
* 归档
*
* @param srcPath
* @throws Exception
*/
public static void archive(String srcPath) throws Exception {
File srcFile = new File(srcPath);
archive(srcFile);
}
/**
* 归档
*
* @param srcFile
* 源路径
* @param taos
* TarArchiveOutputStream
* @param basePath
* 归档包内相对路径
* @throws Exception
*/
private static void archive(File srcFile, TarArchiveOutputStream taos,
String basePath) throws Exception {
if (srcFile.isDirectory()) {
archiveDir(srcFile, taos, basePath);
} else {
archiveFile(srcFile, taos, basePath);
}
}
/**
* 目录归档
*
* @param dir
* @param taos
* TarArchiveOutputStream
* @param basePath
* @throws Exception
*/
private static void archiveDir(File dir, TarArchiveOutputStream taos,
String basePath) throws Exception {
File[] files = dir.listFiles();
if (files.length < 1) {
TarArchiveEntry entry = new TarArchiveEntry(basePath
+ dir.getName() + PATH);
taos.putArchiveEntry(entry);
taos.closeArchiveEntry();
}
for (File file : files) {
// 递归归档
archive(file, taos, basePath + dir.getName() + PATH);
}
}
/**
* 数据归档
*
* @param data
* 待归档数据
* @param path
* 归档数据的当前路径
* @param name
* 归档文件名
* @param taos
* TarArchiveOutputStream
* @throws Exception
*/
private static void archiveFile(File file, TarArchiveOutputStream taos,
String dir) throws Exception {
/**
* 归档内文件名定义
*
* <pre>
* 如果有多级目录，那么这里就需要给出包含目录的文件名
* 如果用WinRAR打开归档包，中文名将显示为乱码
* </pre>
*/
TarArchiveEntry entry = new TarArchiveEntry(dir + file.getName());
entry.setSize(file.length());
taos.putArchiveEntry(entry);
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
file));
int count;
byte data[] = new byte[BUFFER];
while ((count = bis.read(data, 0, BUFFER)) != -1) {
taos.write(data, 0, count);
}
bis.close();
taos.closeArchiveEntry();
}
/**
* 解归档
*
* @param srcFile
* @throws Exception
*/
public static void dearchive(File srcFile) throws Exception {
String basePath = srcFile.getParent();
dearchive(srcFile, basePath);
}
/**
* 解归档
*
* @param srcFile
* @param destFile
* @throws Exception
*/
public static void dearchive(File srcFile, File destFile) throws Exception {
TarArchiveInputStream tais = new TarArchiveInputStream(
new FileInputStream(srcFile));
dearchive(destFile, tais);
tais.close();
}
/**
* 解归档
*
* @param srcFile
* @param destPath
* @throws Exception
*/
public static void dearchive(File srcFile, String destPath)
throws Exception {
dearchive(srcFile, new File(destPath));
}
/**
* 文件解归档
*
* @param destFile
* 目标文件
* @param tais
* ZipInputStream
* @throws Exception
*/
private static void dearchive(File destFile, TarArchiveInputStream tais)
throws Exception {
TarArchiveEntry entry = null;
while ((entry = tais.getNextTarEntry()) != null) {
// 文件
String dir = destFile.getPath() + File.separator + entry.getName();
File dirFile = new File(dir);
// 文件检查
fileProber(dirFile);
if (entry.isDirectory()) {
dirFile.mkdirs();
} else {
dearchiveFile(dirFile, tais);
}
}
}
/**
* 文件解归档
*
* @param srcPath
* 源文件路径
*
* @throws Exception
*/
public static void dearchive(String srcPath) throws Exception {
File srcFile = new File(srcPath);
dearchive(srcFile);
}
/**
* 文件解归档
*
* @param srcPath
* 源文件路径
* @param destPath
* 目标文件路径
* @throws Exception
*/
public static void dearchive(String srcPath, String destPath)
throws Exception {
File srcFile = new File(srcPath);
dearchive(srcFile, destPath);
}
/**
* 文件解归档
*
* @param destFile
* 目标文件
* @param tais
* TarArchiveInputStream
* @throws Exception
*/
private static void dearchiveFile(File destFile, TarArchiveInputStream tais)
throws Exception {
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(destFile));
int count;
byte data[] = new byte[BUFFER];
while ((count = tais.read(data, 0, BUFFER)) != -1) {
bos.write(data, 0, count);
}
bos.close();
}
/**
* 文件探针
*
* <pre>
* 当父目录不存在时，创建目录！
* </pre>
*
* @param dirFile
*/
private static void fileProber(File dirFile) {
File parentFile = dirFile.getParentFile();
if (!parentFile.exists()) {
// 递归寻找上级目录
fileProber(parentFile);
parentFile.mkdir();
}
}
}

复制代码

最后给出测试用例：

/**
* 2010-4-20
*/
package org.zlex.commons.compress;
import static org.junit.Assert.*;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import org.junit.Before;
import org.junit.Test;
/**
* Tar测试
*
* @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>
* @since 1.0
*/
public class TarUtilsTest {
private String inputStr;
private String name = "data.xml";
@Before
public void before() {
StringBuilder sb = new StringBuilder();
sb.append("<?xml version=\"1.0\" encoding=\"utf-8\" ?>");
sb.append("\r\n");
sb.append("<dataGroup>");
sb.append("\r\n\t");
sb.append("<dataItem>");
sb.append("\r\n\t\t");
sb.append("<data>");
sb.append("Test");
sb.append("</data>");
sb.append("\r\n\t");
sb.append("<dataItem>");
sb.append("\r\n");
sb.append("</dataGroup>");
inputStr = sb.toString();
}
@Test
public void testArchiveFile() throws Exception {
byte[] contentOfEntry = inputStr.getBytes();
String path = "d:/" + name;
FileOutputStream fos = new FileOutputStream(path);
fos.write(contentOfEntry);
fos.flush();
fos.close();
TarUtils.archive(path);
TarUtils.dearchive(path + ".tar");
File file = new File(path);
FileInputStream fis = new FileInputStream(file);
DataInputStream dis = new DataInputStream(fis);
byte[] data = new byte[(int) file.length()];
dis.readFully(data);
fis.close();
String outputStr = new String(data);
assertEquals(inputStr, outputStr);
}
@Test
public void testArchiveDir() throws Exception {
String path = "d:/fd";
TarUtils.archive(path);
TarUtils.dearchive(path + ".tar", "d:/fds");
}
}

复制代码

执行代码，来看下效果：

这是原始文件。

这是归档后的文件。
注意红框，这里没有经过任何压缩！
除了tar、zip，其实还有很多归档算法，如ar、jar、cpio。其实现方式，与上述内容较为接近。
至于压缩成*.tar.gz、*.tar.bz2，请朋友们参照前几篇内容！

完整实现见附件！

水玲珑 · 发表于 2015-1-11 17:10:44

顶........

我是一个兵 · 发表于 2016-8-17 16:58:29

看看。。。。。。。。。

帐号		自动登录	找回密码
密码			立即注册

[后台技术] Java压缩技术

相关帖子

Java压缩技术（二） ZIP压缩——Java原生实现

本帖子中包含更多资源

Java压缩技术（四） GZIP——Java原生实现

本帖子中包含更多资源

Java压缩技术（五） GZIP相关——浏览器解析

本帖子中包含更多资源

Java压缩技术（六） BZIP2——Commons实现

本帖子中包含更多资源

本帖子中包含更多资源

开源英雄

守望者

站长推荐 /4