`

Java压缩技术 GZIP——Java原生实现

 
阅读更多

相关链接: 
Java压缩技术(一) ZLib 
Java压缩技术(二) ZIP压缩——Java原生实现 
Java压缩技术(三) ZIP解压缩——Java原生实现 
Java压缩技术(四) GZIP——Java原生实现 
Java压缩技术(五) GZIP相关——浏览器解析 
Java压缩技术(六) BZIP2——Commons实现 
Java压缩技术(七) TAR——Commons实现 

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

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

Java代码  收藏代码
  1. /** 
  2.  * 数据压缩 
  3.  *  
  4.  * @param is 
  5.  * @param os 
  6.  * @throws Exception 
  7.  */  
  8. public static void compress(InputStream is, OutputStream os)  
  9.         throws Exception {  
  10.   
  11.     GZIPOutputStream gos = new GZIPOutputStream(os);  
  12.   
  13.     int count;  
  14.     byte data[] = new byte[BUFFER];  
  15.     while ((count = is.read(data, 0, BUFFER)) != -1) {  
  16.         gos.write(data, 0, count);  
  17.     }  
  18.   
  19.     gos.finish();  
  20.   
  21.     gos.flush();  
  22.     gos.close();  
  23. }  


记得完成操作后,调用finish方法和flush方法! 

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

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

Java代码  收藏代码
  1. /** 
  2.  * 数据解压缩 
  3.  *  
  4.  * @param is 
  5.  * @param os 
  6.  * @throws Exception 
  7.  */  
  8. public static void decompress(InputStream is, OutputStream os)  
  9.         throws Exception {  
  10.   
  11.     GZIPInputStream gis = new GZIPInputStream(is);  
  12.   
  13.     int count;  
  14.     byte data[] = new byte[BUFFER];  
  15.     while ((count = gis.read(data, 0, BUFFER)) != -1) {  
  16.         os.write(data, 0, count);  
  17.     }  
  18.   
  19.     gis.close();  
  20. }  



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

顺便补充一下,在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! 

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

完整实现: 

Java代码  收藏代码
  1. /** 
  2.  * 2010-4-13 
  3.  */  
  4. package org.zlex.commons.io;  
  5.   
  6. import java.io.ByteArrayInputStream;  
  7. import java.io.ByteArrayOutputStream;  
  8. import java.io.File;  
  9. import java.io.FileInputStream;  
  10. import java.io.FileOutputStream;  
  11. import java.io.InputStream;  
  12. import java.io.OutputStream;  
  13. import java.util.zip.GZIPInputStream;  
  14. import java.util.zip.GZIPOutputStream;  
  15.   
  16. /** 
  17.  * GZIP工具 
  18.  *  
  19.  * @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a> 
  20.  * @since 1.0 
  21.  */  
  22. public abstract class GZipUtils {  
  23.   
  24.     public static final int BUFFER = 1024;  
  25.     public static final String EXT = ".gz";  
  26.   
  27.     /** 
  28.      * 数据压缩 
  29.      *  
  30.      * @param data 
  31.      * @return 
  32.      * @throws Exception 
  33.      */  
  34.     public static byte[] compress(byte[] data) throws Exception {  
  35.         ByteArrayInputStream bais = new ByteArrayInputStream(data);  
  36.         ByteArrayOutputStream baos = new ByteArrayOutputStream();  
  37.   
  38.         // 压缩  
  39.         compress(bais, baos);  
  40.   
  41.         byte[] output = baos.toByteArray();  
  42.   
  43.         baos.flush();  
  44.         baos.close();  
  45.   
  46.         bais.close();  
  47.   
  48.         return output;  
  49.     }  
  50.   
  51.     /** 
  52.      * 文件压缩 
  53.      *  
  54.      * @param file 
  55.      * @throws Exception 
  56.      */  
  57.     public static void compress(File file) throws Exception {  
  58.         compress(file, true);  
  59.     }  
  60.   
  61.     /** 
  62.      * 文件压缩 
  63.      *  
  64.      * @param file 
  65.      * @param delete 
  66.      *            是否删除原始文件 
  67.      * @throws Exception 
  68.      */  
  69.     public static void compress(File file, boolean delete) throws Exception {  
  70.         FileInputStream fis = new FileInputStream(file);  
  71.         FileOutputStream fos = new FileOutputStream(file.getPath() + EXT);  
  72.   
  73.         compress(fis, fos);  
  74.   
  75.         fis.close();  
  76.         fos.flush();  
  77.         fos.close();  
  78.   
  79.         if (delete) {  
  80.             file.delete();  
  81.         }  
  82.     }  
  83.   
  84.     /** 
  85.      * 数据压缩 
  86.      *  
  87.      * @param is 
  88.      * @param os 
  89.      * @throws Exception 
  90.      */  
  91.     public static void compress(InputStream is, OutputStream os)  
  92.             throws Exception {  
  93.   
  94.         GZIPOutputStream gos = new GZIPOutputStream(os);  
  95.   
  96.         int count;  
  97.         byte data[] = new byte[BUFFER];  
  98.         while ((count = is.read(data, 0, BUFFER)) != -1) {  
  99.             gos.write(data, 0, count);  
  100.         }  
  101.   
  102.         gos.finish();  
  103.   
  104.         gos.flush();  
  105.         gos.close();  
  106.     }  
  107.   
  108.     /** 
  109.      * 文件压缩 
  110.      *  
  111.      * @param path 
  112.      * @throws Exception 
  113.      */  
  114.     public static void compress(String path) throws Exception {  
  115.         compress(path, true);  
  116.     }  
  117.   
  118.     /** 
  119.      * 文件压缩 
  120.      *  
  121.      * @param path 
  122.      * @param delete 
  123.      *            是否删除原始文件 
  124.      * @throws Exception 
  125.      */  
  126.     public static void compress(String path, boolean delete) throws Exception {  
  127.         File file = new File(path);  
  128.         compress(file, delete);  
  129.     }  
  130.   
  131.     /** 
  132.      * 数据解压缩 
  133.      *  
  134.      * @param data 
  135.      * @return 
  136.      * @throws Exception 
  137.      */  
  138.     public static byte[] decompress(byte[] data) throws Exception {  
  139.         ByteArrayInputStream bais = new ByteArrayInputStream(data);  
  140.         ByteArrayOutputStream baos = new ByteArrayOutputStream();  
  141.   
  142.         // 解压缩  
  143.   
  144.         decompress(bais, baos);  
  145.   
  146.         data = baos.toByteArray();  
  147.   
  148.         baos.flush();  
  149.         baos.close();  
  150.   
  151.         bais.close();  
  152.   
  153.         return data;  
  154.     }  
  155.   
  156.     /** 
  157.      * 文件解压缩 
  158.      *  
  159.      * @param file 
  160.      * @throws Exception 
  161.      */  
  162.     public static void decompress(File file) throws Exception {  
  163.         decompress(file, true);  
  164.     }  
  165.   
  166.     /** 
  167.      * 文件解压缩 
  168.      *  
  169.      * @param file 
  170.      * @param delete 
  171.      *            是否删除原始文件 
  172.      * @throws Exception 
  173.      */  
  174.     public static void decompress(File file, boolean delete) throws Exception {  
  175.         FileInputStream fis = new FileInputStream(file);  
  176.         FileOutputStream fos = new FileOutputStream(file.getPath().replace(EXT,  
  177.                 ""));  
  178.         decompress(fis, fos);  
  179.         fis.close();  
  180.         fos.flush();  
  181.         fos.close();  
  182.   
  183.         if (delete) {  
  184.             file.delete();  
  185.         }  
  186.     }  
  187.   
  188.     /** 
  189.      * 数据解压缩 
  190.      *  
  191.      * @param is 
  192.      * @param os 
  193.      * @throws Exception 
  194.      */  
  195.     public static void decompress(InputStream is, OutputStream os)  
  196.             throws Exception {  
  197.   
  198.         GZIPInputStream gis = new GZIPInputStream(is);  
  199.   
  200.         int count;  
  201.         byte data[] = new byte[BUFFER];  
  202.         while ((count = gis.read(data, 0, BUFFER)) != -1) {  
  203.             os.write(data, 0, count);  
  204.         }  
  205.   
  206.         gis.close();  
  207.     }  
  208.   
  209.     /** 
  210.      * 文件解压缩 
  211.      *  
  212.      * @param path 
  213.      * @throws Exception 
  214.      */  
  215.     public static void decompress(String path) throws Exception {  
  216.         decompress(path, true);  
  217.     }  
  218.   
  219.     /** 
  220.      * 文件解压缩 
  221.      *  
  222.      * @param path 
  223.      * @param delete 
  224.      *            是否删除原始文件 
  225.      * @throws Exception 
  226.      */  
  227.     public static void decompress(String path, boolean delete) throws Exception {  
  228.         File file = new File(path);  
  229.         decompress(file, delete);  
  230.     }  
  231.   
  232. }  



罗嗦了半天,到底行不行? 
来个测试用例,测试用例如下所示: 

Java代码  收藏代码
  1. /** 
  2.  * 2010-4-13 
  3.  */  
  4. package org.zlex.commons.compress.compress;  
  5.   
  6. import static org.junit.Assert.assertEquals;  
  7.   
  8. import java.io.DataInputStream;  
  9. import java.io.File;  
  10. import java.io.FileInputStream;  
  11. import java.io.FileOutputStream;  
  12.   
  13. import org.junit.Test;  
  14.   
  15. /** 
  16.  * @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a> 
  17.  * @since 1.0 
  18.  */  
  19. public class GZipUtilsTest {  
  20.   
  21.     private String inputStr = "zlex@zlex.org,snowolf@zlex.org,zlex.snowolf@zlex.org";  
  22.   
  23.     @Test  
  24.     public final void testDataCompress() throws Exception {  
  25.   
  26.         System.err.println("原文:\t" + inputStr);  
  27.   
  28.         byte[] input = inputStr.getBytes();  
  29.         System.err.println("长度:\t" + input.length);  
  30.   
  31.         byte[] data = GZipUtils.compress(input);  
  32.         System.err.println("压缩后:\t");  
  33.         System.err.println("长度:\t" + data.length);  
  34.   
  35.         byte[] output = GZipUtils.decompress(data);  
  36.         String outputStr = new String(output);  
  37.         System.err.println("解压缩后:\t" + outputStr);  
  38.         System.err.println("长度:\t" + output.length);  
  39.   
  40.         assertEquals(inputStr, outputStr);  
  41.   
  42.     }  
  43.   
  44.     @Test  
  45.     public final void testFileCompress() throws Exception {  
  46.   
  47.         FileOutputStream fos = new FileOutputStream("d:/f.txt");  
  48.   
  49.         fos.write(inputStr.getBytes());  
  50.         fos.flush();  
  51.         fos.close();  
  52.   
  53.         GZipUtils.compress("d:/f.txt"false);  
  54.   
  55.         GZipUtils.decompress("d:/f.txt.gz"false);  
  56.   
  57.         File file = new File("d:/f.txt");  
  58.   
  59.         FileInputStream fis = new FileInputStream(file);  
  60.   
  61.         DataInputStream dis = new DataInputStream(fis);  
  62.   
  63.         byte[] data = new byte[(int) file.length()];  
  64.         dis.readFully(data);  
  65.   
  66.         fis.close();  
  67.   
  68.         String outputStr = new String(data);  
  69.         assertEquals(inputStr, outputStr);  
  70.     }  
  71. }  


结果如何? 
先看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等)的实现,有机会我将继续整理! 

相关链接: 
Java压缩技术(一) ZLib 
Java压缩技术(二) ZIP压缩——Java原生实现 
Java压缩技术(三) ZIP解压缩——Java原生实现 
Java压缩技术(四) GZIP——Java原生实现 
Java压缩技术(五) GZIP相关——浏览器解析 
Java压缩技术(六) BZIP2——Commons实现 
Java压缩技术(七) TAR——Commons实现

分享到:
评论

相关推荐

    Java压缩技术(四) GZIP——Java原生实现

    本篇文章主要聚焦于Java原生实现的GZIP压缩技术。GZIP是一种广泛使用的压缩算法,它基于DEFLATE算法,同时也被用于创建.gz格式的压缩文件。在Java中,我们可以直接使用java.util.zip包下的GZIPOutputStream和...

    java压缩技术

    ZLib ZIP 压缩——Java 原生实现 ZIP 解压缩——Java 原生实现 GZIP——Java 原生实现 GZIP 相关——浏览器解析 BZIP2——Commons 实现 TAR——Commons 实现

    Java压缩技术(五) GZIP相关——浏览器解析

    总之,Java的GZIP压缩技术在Web开发中扮演着重要角色,能够有效地减小数据传输量,提升用户体验。通过理解和应用这些知识,开发者可以构建更高效、更快速的网络服务。同时,深入源码有助于我们掌握更底层的细节,为...

    java实现gzip ajax请求gzip压缩

    Java作为后端开发的重要语言,支持处理gzip压缩,而Ajax(Asynchronous JavaScript and XML)则是前端进行异步数据交互的技术。本文将深入探讨如何在Java后端实现对gzip压缩的处理,以便于Ajax请求能够正确地进行...

    Java压缩技术(七) TAR——Commons实现

    在Java编程中,压缩技术是数据存储和传输中不可或缺的一部分。本篇主要关注的是TAR格式的压缩,它是Unix/Linux环境中广泛使用的文件打包格式。在Java中,Apache Commons Compress库提供了一个方便的API来处理TAR文件...

    Java用GZIP压缩解压文件源码

    在本文中,我们将深入探讨如何使用Java实现GZIP压缩和解压缩文件的源码。 首先,我们需要引入Java的`java.util.zip`包,这个包包含了处理GZIP和其他压缩格式所需的类。在Java中,`GZIPOutputStream`和`...

    java压缩文件以及文件夹

    首先,让我们了解`java.util.zip`包,它是Java标准库中用于处理ZIP和GZIP格式的压缩的工具。`ZipOutputStream`和`ZipEntry`是这个包中的关键类,它们用于创建和管理ZIP文件。 1. **ZipOutputStream**: - `...

    Java用GZIP压缩解压文件.rar

    一个Java随书实例:用GZIP压缩解压文件,从源文件得到文件输入流,得到目标文件输出流,得到压缩输出流,设定读入缓冲区尺寸,弹出文件选择器,并判断是否点击了打开按钮,判断事件来自于哪个按钮,用于选择解压和...

    java自带压缩方式的性能比较

    在`GzipUtils.java`和`ZipUtils.java`中,作者可能实现了一些功能,如压缩和解压缩的方法。这些方法可能使用了Java内置的`java.util.zip`包,其中`GZIPOutputStream`和`GZIPInputStream`对应Gzip操作,而`...

    Java用GZIP压缩解压文件

    在Java编程环境中,GZIP是一种常用的文件压缩格式,它基于DEFLATE算法,可以有效地减少文件大小,便于存储和传输。本篇文章将深入探讨如何在Java中使用GZIP进行文件的压缩与解压缩操作。 首先,我们需要了解Java中...

    java_gzip.rar_Compression_gzip_j2me gz_java压缩

    GZIP是一种广泛使用的数据压缩格式,其在Java中的实现基于Java IO和Java util.zip库。本篇将详细介绍Java中如何利用GZIP进行数据压缩和解压缩,并结合`java_gzip.txt`和`www.pudn.com.txt`这两个文件来展示实际操作...

    JAVA文件压缩与解压缩实践(源代码+论文)

    1. **Java压缩库**:Java标准库提供了`java.util.zip`包,它包含了多种压缩和解压缩的类,如`ZipOutputStream`、`ZipInputStream`、`GZIPOutputStream`和`GZIPInputStream`,用于处理ZIP和GZIP格式的文件。...

    LZW实现Java压缩解压

    在Java编程环境中,我们可以利用LZW算法实现文件的压缩和解压缩功能。以下是对LZW算法及其Java实现的详细解释: 1. **LZW算法原理**: LZW算法基于词典编码思想,它通过查找或构建一个动态更新的词典来压缩数据。...

    java实现压缩与解压缩

    总之,Java提供了一套完整的API来处理文件的压缩和解压缩,无论是基础的ZIP和GZIP,还是通过第三方库实现的更多压缩格式。在实际开发中,了解并掌握这些工具和技巧对于优化文件存储和传输效率至关重要。

    gzip.rar_C gzip源码_c语言gzip_gzip压缩_gzip解压_poetryfem

    理解gzip的C语言实现不仅有助于深入学习文件压缩技术,还能帮助开发者提高处理二进制数据和低级别I/O操作的能力。同时,这对于那些想要自定义压缩算法或在嵌入式系统上实现轻量级压缩的开发者来说尤其有价值。通过对...

    Java用GZIP压缩解压文件.7z

    在Java编程语言中,GZIP是一种常用的文件压缩格式,它基于DEFLATE算法,可以用于压缩和解压缩数据。在处理大文件或者网络传输时,使用GZIP进行压缩可以显著减少数据量,提高效率。本篇文章将深入探讨如何在Java中...

    利用JAVASCRIPT即你想那个GZIP压缩与解压缩

    标题中的“利用JAVASCRIPT实现GZIP压缩与解压缩”指的是在JavaScript环境中,我们可以使用原生或第三方库来处理GZIP格式的压缩和解压缩操作。GZIP是一种广泛使用的数据压缩格式,常用于减少网络传输的数据量,尤其是...

    java实现压缩和解压.doc

    本文将深入探讨如何使用Java实现这一功能,主要关注两种常用的压缩格式:ZIP和GZ。 首先,我们要引入Java的内置库`java.util.zip`,它提供了处理ZIP和GZIP格式的类。对于ZIP格式,我们主要使用`ZipOutputStream`来...

    基于java的用GZIP压缩解压文件.zip

    总之,这个压缩包文件包含了使用Java进行GZIP压缩和解压缩的基本示例,是学习和理解Java文件压缩技术的好资源。通过学习和实践这些示例,开发者可以掌握如何在实际项目中高效地处理GZIP压缩文件。

Global site tag (gtag.js) - Google Analytics