GZIP 与zip区别

Posted 2023-04-15

一、主体不同

1、GZIP：最早由Jean-loup Gailly和Mark Adler创建，用于UNⅨ系统的文件压缩。

2、ZIP：ZIP文件格式是一种数据压缩和文档储存的文件格式。

二、特点不同

1、GZIP：基础是DEFLATE，DEFLATE是LZ77与哈夫曼编码的一个组合体。DEFLATE最初是作为LZW以及其它受专利保护的数据压缩算法的替代版本而设计的。

2、ZIP：是一种相当简单的分别压缩每个文件的存档格式。分别压缩文件允许不必读取另外的数据而检索独立的文件。

三、优点不同

1、GZIP：可以减少存储空间，通过网络传输文件时，可以减少传输的时间。

2、ZIP：支持基于对称加密系统的一个简单的密码，已知有严重的缺陷，已知明文攻击，字典攻击和暴力攻击。

参考资料来源：百度百科-gzip

参考资料来源：百度百科-Zip

参考技术A GZIP 与zip区别主要是适应系统不同，还有就是压缩率不一样；
普遍使用的是zip压缩，Windows系统下就用zip
gzip为高压，可以把文件压缩得更小，便于放网盘或者网上供人下载；gzip是Linux下面用的格式，一般在Linux下解压，如果用Windows下的程序解压有可能丢失其中某些文件或属性。 参考技术B zip是将文件打包为zip格式的压缩文件
gzip是将文件打包为tar.gz格式的压缩文件本回答被提问者和网友采纳 参考技术C 都是一种文件压缩格式，不过GZIP用在HTTP协议上是一种用来改进WEB应用程序性能的技术。将网页内容压缩后再传输，大流量的WEB站点常常使用GZIP压缩技术来让用户感受更快的速度

在java中，gzip 压缩和解压多个文件？

在java中，gzip 压缩和解压多个文件？请各位大侠帮忙
我要的是gzip 压缩解压多个文件，不是zip，还有1楼那个压缩无法解压，解压和压缩时不一样的。

直接编译运行！！！

不知道你是要查看压缩文件还是要解压文件，所以发上来两个。
第一个可以查看各个压缩项目；
第二个可以解压文件。

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import java.util.zip.*;
import javax.swing.*;
import javax.swing.filechooser.FileFilter;

class ZipTest
public static void main(String[] args)
ZipTestFrame frame = new ZipTestFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);



class ZipTestFrame extends JFrame

private JComboBox fileCombo;
private JTextArea fileText;
private String zipname;

public ZipTestFrame()

setTitle("ZipTest");
setSize(400,300);

JMenuBar menuBar = new JMenuBar();
JMenu menu = new JMenu("File");

JMenuItem openItem = new JMenuItem("Open");
menu.add(openItem);
openItem.addActionListener(new OpenAction());

JMenuItem exitItem = new JMenuItem("Exit");
menu.add(exitItem);
exitItem.addActionListener(new ActionListener()
public void actionPerformed(ActionEvent event)
System.exit(0);

);

menuBar.add(menu);
setJMenuBar(menuBar);

fileText = new JTextArea();
fileCombo = new JComboBox();
fileCombo.addActionListener(new ActionListener()
public void actionPerformed(ActionEvent event)
loadZipFile((String)fileCombo.getSelectedItem());

);
add(fileCombo, BorderLayout.SOUTH);
add(new JScrollPane(fileText), BorderLayout.CENTER);


public class OpenAction implements ActionListener
public void actionPerformed(ActionEvent event)
JFileChooser chooser = new JFileChooser();
chooser.setCurrentDirectory(new File("."));
ExtensionFileFilter filter = new ExtensionFileFilter();
filter.addExtension(".zip");
filter.addExtension(".jar");
filter.setDescription("ZIP archives");
chooser.setFileFilter(filter);
int r = chooser.showOpenDialog(ZipTestFrame.this);
if(r == JFileChooser.APPROVE_OPTION)
zipname = chooser.getSelectedFile().getPath();
scanZipFile();




public void scanZipFile()
fileCombo.removeAllItems();
try
ZipInputStream zin = new ZipInputStream(new FileInputStream(zipname));
ZipEntry entry;
while((entry = zin.getNextEntry()) != null)
fileCombo.addItem(entry.getName());
zin.closeEntry();

zin.close();
catch(IOException e)
e.printStackTrace();



public void loadZipFile(String name)
try
ZipInputStream zin = new ZipInputStream(new FileInputStream(zipname));
ZipEntry entry;
fileText.setText("");

while((entry = zin.getNextEntry()) != null)
if(entry.getName().equals(name))
BufferedReader in = new BufferedReader(new InputStreamReader(zin));
String line;
while((line = in.readLine())!=null)
fileText.append(line);
fileText.append("\n");


zin.closeEntry();

zin.close();
catch(IOException e)
e.printStackTrace();




class ExtensionFileFilter extends FileFilter

private String description = "";
private ArrayList<String>extensions = new ArrayList<String>();

public void addExtension(String extension)
if(!extension.startsWith("."))
extension = "." + extension;
extensions.add(extension.toLowerCase());


public void setDescription(String aDescription)
description = aDescription;


public String getDescription()
return description;


public boolean accept(File f)
if(f.isDirectory()) return true;
String name = f.getName().toLowerCase();

for(String e : extensions)
if(name.endsWith(e))
return true;
return false;



///////////////////////////////////////////////////////////
/**
*类名：zipFileRelease
*说明：一个zip文件解压类
*介绍：主要的zip文件释放方法releaseHandle()
* 用ZipInputStream类和ZipEntry类将zip文件的入口清单列举出来，然后
* 根据用户提供的输出路径和zip文件的入口进行组合通过DataOutputStream
* 和File类进行文件的创建和目录的创建，创建文件时的文件数据是通过
* ZipInputStream类、ZipEntry类、InputStream类之间的套嵌组合获得的。
*注意：如果zip文件中包含中文路径程序将会抛出异常
*/

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

class zipFileRelease

private String inFilePath;
private String releaseFilePath;
private String[] FileNameArray; //存放文件名称的数组
private ZipEntry entry;
//
private FileInputStream fileDataIn;
private FileOutputStream fileDataOut;
private ZipInputStream zipInFile;
private DataOutputStream writeData;
private DataInputStream readData;
//
private int zipFileCount = 0; //zip文件中的文件总数
private int zipPathCount = 0; //zip文件中的路径总数

/**
*初始化函数
*初始化zip文件流、输出文件流以及其他变量的初始化
*/
public zipFileRelease(String inpath,String releasepath)
inFilePath = inpath;
releaseFilePath = releasepath;


/**
*初始化读取文件流函数
*参数：FileInputStream类
*返回值：初始化成功返回0，否则返回-1
*/
protected long initInStream(ZipInputStream zipFileA)
try
readData = new DataInputStream(zipFileA);
return 0;
catch(Exception e)
e.printStackTrace();
return -1;



/**
*测试文件路径
*参数：zip文件的路径和要释放的位置
*返回值：是两位整数，两位数中的十位代表输入路径和输出路径(1输入、2输出)
* 各位数是代表绝对路径还是相对路径(1绝对、0相对)
* 返回-1表示路径无效

protected long checkPath(String inPath,String outPath)
File infile = new File(inPath);
File infile = new File(outPath);


*/

/**
*初始化输出文件流
*参数：File类
*返回值：初始化成功返回0，否则返回-1
*/
protected long initOutStream(String outFileA)
try
fileDataOut = new FileOutputStream(outFileA);
writeData = new DataOutputStream(fileDataOut);
return 0;
catch(IOException e)
e.printStackTrace();
return -1;



/**
*测试文件是否存在方法
*参数：File类
*返回值：如果文件存在返回文件大小，否则返回-1
*/
public long checkFile(File inFileA)
if (inFileA.exists())
return 0;
else
return -1;



/**
*判断文件是否可以读取方法
*参数：File类
*返回值：如果可以读取返回0，否则返回-1
*/
public long checkOpen(File inFileA)
if(inFileA.canRead())
return inFileA.length();
else
return -1;



/**
*获得zip文件中的文件夹和文件总数
*参数：File类
*返回值：如果正常获得则返回总数，否则返回-1
*/
public long getFilFoldCount(String infileA)
try
int fileCount = 0;
zipInFile = new ZipInputStream(new FileInputStream(infileA));
while ((entry = zipInFile.getNextEntry()) != null)
if (entry.isDirectory())
zipPathCount++;
else
zipFileCount++;

fileCount++;

return fileCount;
catch(IOException e)
e.printStackTrace();
return -1;



/**
*读取zip文件清单函数
*参数：File类
*返回值：文件清单数组
*/
public String[] getFileList(String infileA)
try
ZipInputStream AzipInFile = new ZipInputStream(new FileInputStream(infileA));
//创建数组对象
FileNameArray = new String[(int)getFilFoldCount(infileA)];

//将文件名清单传入数组
int i = 0;
while ((entry = AzipInFile.getNextEntry()) != null)
FileNameArray[i++] = entry.getName();

return FileNameArray;
catch(IOException e)
e.printStackTrace();
return null;



/**
*创建文件函数
*参数：File类
*返回值:如果创建成功返回0，否则返回-1
*/
public long writeFile(String outFileA,byte[] dataByte)
try
if (initOutStream(outFileA) == 0)
writeData.write(dataByte);
fileDataOut.close();
return 0;
else
fileDataOut.close();
return -1;

catch(IOException e)
e.printStackTrace();
return -1;



/**
*读取文件内容函数
*参数：File类
*返回值:如果读取成功则返回读取数据的字节数组，如果失败则返回空值
*/
protected byte[] readFile(ZipEntry entryA,ZipInputStream zipFileA)
try
long entryFilelen;
if (initInStream(zipFileA) == 0)
if ((entryFilelen = entryA.getSize()) >= 0)
byte[] entryFileData = new byte[(int)entryFilelen];
readData.readFully(entryFileData,0,(int)entryFilelen);
return entryFileData;
else
return null;

else
return null;

catch(IOException e)
e.printStackTrace();
return null;



/**
*创建目录函数
*参数：要创建目录的路径
*返回值：如果创建成功则返回0，否则返回-1
*/
public long createFolder(String dir)
File file = new File(dir);
if (file.mkdirs())
return 0;
else
return -1;



/**
*删除文件
*参数：要删除的文件
*返回值：如果删除成功则返回0，要删除的文件不存在返回-2
* 如果要删除的是个路径则返回-3，删除失败则返回-1
*/
public long deleteFile(String Apath) throws SecurityException
File file = new File(Apath.trim());
//文件或路径不存在
if (!file.exists())
return -2;

//要删除的是个路径
if (!file.isFile())
return -3;

//删除
if (file.delete())
return 0;
else
return -1;



/**
*删除目录
*参数：要删除的目录
*返回值：如果删除成功则返回0，删除失败则返回-1
*/
public long deleteFolder(String Apath)
File file = new File(Apath);
//删除
if (file.delete())
return 0;
else
return -1;



/**
*判断所要解压的路径是否存在同名文件
*参数：解压路径
*返回值：如果存在同名文件返回-1，否则返回0
*/
public long checkPathExists(String AreleasePath)
File file = new File(AreleasePath);
if (!file.exists())
return 0;
else
return -1;



/**
*删除zip中的文件
*参数：文件清单数组，释放路径
*返回值：如果删除成功返回0,否则返回-1
*/
protected long deleteReleaseZipFile(String[] listFilePath,String releasePath)
long arrayLen,flagReturn;
int k = 0;
String tempPath;
//存放zip文件清单的路径
String[] pathArray = new String[zipPathCount];
//删除文件
arrayLen = listFilePath.length;
for(int i=0;i<(int)arrayLen;i++)
tempPath = releasePath.replace('\\','/') + listFilePath[i];
flagReturn = deleteFile(tempPath);
if (flagReturn == -2)
//什么都不作
else if (flagReturn == -3)
pathArray[k++] = tempPath;
else if (flagReturn == -1)
return -1;


//删除路径
for(k = k - 1;k>=0;k--)
flagReturn = deleteFolder(pathArray[k]);
if (flagReturn == -1) return -1;

return 0;


/**
*获得zip文件的最上层的文件夹名称
*参数：zip文件路径
*返回值：文件夹名称，如果失败则返回null
*/
public String getZipRoot(String infileA)
String rootName;
try
FileInputStream tempfile = new FileInputStream(infileA);
ZipInputStream AzipInFile = new ZipInputStream(tempfile);
ZipEntry Aentry;
Aentry = AzipInFile.getNextEntry();
rootName = Aentry.getName();
tempfile.close();
AzipInFile.close();
return rootName;
catch(IOException e)
e.printStackTrace();
return null;



/**
*释放流，释放占用资源
*/
protected void closeStream() throws Exception
fileDataIn.close();
fileDataOut.close();
zipInFile.close();
writeData.flush();


/**
*解压函数
*对用户的zip文件路径和解压路径进行判断，是否存在和打开
*在输入解压路径时如果输入"/"则在和zip文件存放的统计目录下进行解压
*返回值：0表示释放成功
* -1 表示您所要解压的文件不存在、
* -2表示您所要解压的文件不能被打开、
* -3您所要释放的路径不存在、
* -4您所创建文件目录失败、
* -5写入文件失败、
* -6表示所要释放的文件已经存在、
* -50表示文件读取异常
*/
public long releaseHandle() throws Exception
File inFile = new File(inFilePath);
File outFile = new File(releaseFilePath);
String tempFile;
String zipPath;
String zipRootPath;
String tempPathParent; //存放释放路径
byte[] zipEntryFileData;

//作有效性判断
if (checkFile(inFile) == -1)
return -1;
if (checkOpen(inFile) == -1)
return -2;
//不是解压再当前目录下时对路径作有效性检验
if (!releaseFilePath.equals("/"))
//解压在用户指定目录下
if (checkFile(outFile) == -1)
return -3;

//获得标准释放路径
if (!releaseFilePath.equals("/"))
tempPathParent = releaseFilePath.replace('\\','/')+ "/";
else
tempPathParent = inFile.getParent().replace('\\','/')+ "/";

//获得zip文件中的入口清单
FileNameArray = getFileList(inFilePath);
//获得zip文件的最上层目录
zipRootPath = getZipRoot(inFilePath);
//
fileDataIn = new FileInputStream(inFilePath);
zipInFile = new ZipInputStream(fileDataIn);
//判断是否已经存在要释放的文件夹
if (zipRootPath.lastIndexOf("/") > 0 )
if (checkPathExists(tempPathParent +
zipRootPath.substring(0,zipRootPath.lastIndexOf("/"))) == -1)
return -6;

else
if (checkPathExists(tempPathParent + zipRootPath) == -1)
return -6;



//
try
//创建文件夹和文件
int i = 0;
while ((entry = zipInFile.getNextEntry()) != null)
if (entry.isDirectory())
//创建目录
zipPath = tempPathParent + FileNameArray[i];
zipPath = zipPath.substring(0,zipPath.lastIndexOf("/"));
if (createFolder(zipPath) == -1)
closeStream();
deleteReleaseZipFile(FileNameArray,tempPathParent);
return -4;


else
//读取文件数据
zipEntryFileData = readFile(entry,zipInFile);
//向文件写数据
tempFile = tempPathParent + FileNameArray[i];
//写入文件
if (writeFile(tempFile,zipEntryFileData) == -1)
closeStream();
deleteReleaseZipFile(FileNameArray,tempPathParent);
return -5;


i++;

//释放资源
closeStream();
return 0;
catch(Exception e)
closeStream();
deleteReleaseZipFile(FileNameArray,tempPathParent);
e.printStackTrace();
return -50;


/**
*演示函数
*根据用户输入的路径对文件进行解压
*/
public static void main(String args[]) throws Exception

long flag; //返回标志
String inPath,releasePath;

//获得用户输入信息
BufferedReader userInput = new BufferedReader(
new InputStreamReader(System.in));
System.out.println("请输入zip文件路径：");
inPath = userInput.readLine();
System.out.println("请输入保存路径：");
releasePath = userInput.readLine();
userInput.close();

//执行解压缩
zipFileRelease pceraZip = new zipFileRelease(inPath,releasePath);
flag = pceraZip.releaseHandle();

//出错信息打印
if (flag == 0) System.out.println("释放成功！！！");
if (flag == -1) System.out.println("您所要解压的文件不存在！");
if (flag == -2) System.out.println("您所要解压的文件不能被打开！");
if (flag == -3) System.out.println("您所要释放的路径不存在！");
if (flag == -4) System.out.println("您所创建文件目录失败！");
if (flag == -5) System.out.println("写入文件失败！");
if (flag == -6) System.out.println("文件已经存在！");
if (flag == -50) System.out.println("文件读取异常！");

参考技术A 40.ZIP压缩文件
//import java.io.*;
//import java.util.zip.*;
//创建文件输入流对象
FileInputStream fis=new FileInputStream(%%1);
//创建文件输出流对象
FileOutputStream fos=new FileOutputStream(%%2);
//创建ZIP数据输出流对象
ZipOutputStream zipOut=new ZipOutputStream(fos);
//创建指向压缩原始文件的入口
ZipEntry entry=new ZipEntry(args[0]);
zipOut.putNextEntry(entry);
//向压缩文件中输出数据
int nNumber;
byte[] buffer=new byte[1024];
while((nNumber=fis.read(buffer))!=-1)
zipOut.write(buffer,0,nNumber);
//关闭创建的流对象
zipOut.close();
fos.close();
fis.close();

catch(IOException e)

System.out.println(e);


42.ZIP解压缩
//import java.io.*;
//import java.util.zip.*;
try
//创建文件输入流对象实例
FileInputStream fis=new FileInputStream(%%1);
//创建ZIP压缩格式输入流对象实例
ZipInputStream zipin=new ZipInputStream(fis);
//创建文件输出流对象实例
FileOutputStream fos=new FileOutputStream(%%2);
//获取Entry对象实例
ZipEntry entry=zipin.getNextEntry();
byte[] buffer=new byte[1024];
int nNumber;
while((nNumber=zipin.read(buffer,0,buffer.length))!=-1)
fos.write(buffer,0,nNumber);
//关闭文件流对象
zipin.close();
fos.close();
fis.close();

catch(IOException e)
System.out.println(e);


43.ZIP压缩文件夹
//import java.io.*;
//import org.apache.tools.zip.ZipOutputStream; //这个包在ant.jar里，要到官方网下载
//import java.util.zip.*;
try
String zipFileName = %%2; //打包后文件名字
File f=new File(%%1);
ZipOutputStream out = new ZipOutputStream(new FileOutputStream(zipFileName));
String base= "";
if (f.isDirectory())
File[] fl = f.listFiles();
out.putNextEntry(new org.apache.tools.zip.ZipEntry(base + "/"));
base = base.length() == 0 ? "" : base + "/";
for (int i = 0; i < fl.length; i++)
zip(out, fl[i], base + fl[i].getName());

else
out.putNextEntry(new org.apache.tools.zip.ZipEntry(base));
FileInputStream in = new FileInputStream(f);
int b;
while ( (b = in.read()) != -1)
out.write(b);

in.close();

out.close();
catch (Exception ex)
ex.printStackTrace();
参考技术B 压缩的，解压类似
public boolean compress(String[] srcFiles, String destFile)

BufferedInputStream in = null;
BufferedOutputStream out = null;
try

out = new BufferedOutputStream(new GZIPOutputStream(
new FileOutputStream(destFile)));
for (String srcFile : srcFiles)

in = new BufferedInputStream(new FileInputStream(srcFile));
while (in.available() != 0)

out.write(in.read());

in.close();

out.close();
return true;

catch (IOException e)

try

if (in != null)
in.close();
if (out != null)
out.close();

catch (IOException e1)

e1.printStackTrace();

e.printStackTrace();
return false;