如何在Java中的ZIP文件中创建ZIP文件

我试图在一个ZIP文件中创建一个ZIP文件，以重新构造我在Java中获得的以前在内存中的ZIP结构

我失败了，因为在初始ZIP文件中创建的内部ZIP出现错误。文件已损坏。试图打开文件时，我得到了一个“意外的文件结尾”

我得到了这个结构：

-input.zip --innerInput.zip

代码使用java堆栈和映射在内存中解压所有内容。然后创建input2.zip，其中包含innerInput.zip

小结：我需要创建一个包含ZIP的ZIP，全部在内存中（暂时不保存在磁盘上）

代码：

import java.io.BufferedInputStream；
导入java.io.BufferedOutputStream；
导入java.io.ByteArrayInputStream；
导入java.io.ByteArrayOutputStream；
导入java.util.ArrayDeque；
导入java.util.ArrayList；
导入java.util.Deque；
导入java.util.HashMap；
导入java.util.LinkedHashMap；
导入java.util.List；
导入java.util.Map；
导入java.util.SortedMap；
导入java.util.zip.ZipEntry；
导入java.util.zip.ZipInputStream；
导入org.apache.commons.lang3.StringUtils；
公共类ZipHandler1{
私有静态最终整数缓冲区大小=2048；
私有静态最终字符串ZIP_EXTENSION=“.ZIP”；
公共静态最终整数文件夹=1；
公共静态最终整数ZIP=2；
公共静态最终整数文件=3；
公共静态数据解压（ByteArrayOutputStream-zippedOutputFile）{
试一试{
ZipInputStream inputStream=新的ZipInputStream(
新建BufferedInputStream（新建ByteArrayInputStream(
ZippeOutputFile.toByteArray（））；
ZipEntry入口；
Deque结果=新的ARRAYDEFUE（）；
while（（entry=inputStream.getnextery（））！=null）{
LinkedHashMap=新建LinkedHashMap（）；
ByteArrayOutputStream outputStream=新建ByteArrayOutputStream（）；
System.out.println（“\tExtracting entry:”+entry）；
整数计数；
字节[]数据=新字节[缓冲区大小]；
如果（！entry.isDirectory（））{
BufferedOutputStream out=新的BufferedOutputStream(
输出流、缓冲区大小）；
while（（count=inputStream.read（数据，0，缓冲区大小））！=-1）{
输出。写入（数据，0，计数）；
}
out.flush（）；
out.close（）；
//递归解压文件
if（entry.getName（）.toUpperCase（）.endsWith（ZIP_扩展名.toUpperCase（）））{
put（ZIP，新对象[]{entry.getName（），解压（outputStream）}）；
结果：添加（map）；
}否则{
put（文件，新对象[]{entry.getName（），outputStream}）；
结果：添加（map）；
}
}否则{
map.put（文件夹，新对象[]{entry.getName（），
解压缩（outputStream）}；
结果：添加（map）；
}
}
inputStream.close（）；
返回结果；
}捕获（例外e）{
抛出新的运行时异常（e）；
}
}
}
赫尔南套餐课程；
导入java.io.BufferedInputStream；
导入java.io.BufferedOutputStream；
导入java.io.ByteArrayInputStream；
导入java.io.ByteArrayOutputStream；
导入java.io.File；
导入java.io.FileInputStream；
导入java.io.FileNotFoundException；
导入java.io.FileOutputStream；
导入java.io.IOException；
导入java.util.ArrayDeque；
导入java.util.Deque；
导入java.util.LinkedHashMap；
导入java.util.List；
导入java.util.Map；
导入java.util.zip.ZipEntry；
导入java.util.zip.ZipInputStream；
导入java.util.zip.ZipoutStream；
导入org.apache.commons.io.IOUtils；
公共类文件读取器{
私有静态最终整数缓冲区大小=2048；
公共静态void main（字符串[]args）{
试一试{
文件f=新文件（“DIR/inputs.zip”）；
FileInputStream fis=新的FileInputStream（f）；
BufferedInputStream bis=新的BufferedInputStream（fis）；
ByteArrayOutputStream bas=新的ByteArrayOutputStream（）；
BufferedOutputStream bos=新的BufferedOutputStream（BAS）；
字节[]缓冲区=新字节[缓冲区大小]；
while（二读（缓冲区，0，缓冲区大小）！=-1）{
写入（缓冲区）；
}
bos.flush（）；
bos.close（）；
二、关闭（）；
Deque outputDataStack=ZipHandler1.unzip（baos）；
//输出文件
File fout=新文件（“DIR/inputs2.zip”）；
ZipOutputStream zipOutput=new-ZipOutputStream（new-BufferedOutputStream（new-FileOutputStream（fout））；
processZip（outputDataStack、zipOutput）；
zipOutput.close（）；
}catch（filenotfounde异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
私有静态最终void processZip（Deque outputDataStack，
zipOutput流（zipOutput）引发IOException{
而（！outputDataStack.isEmpty（））{
Map Map=outputDataStack.pop（）；
对于（Map.Entry:Map.entrySet（））{
System.out.println（“KEY:+entry.getKey（））；
Object[]values=entry.getValue（）；
String entryName=（字符串）值[0]；
if（entry.getKey（）.equals（ZipHandler1.FILE））{
系统输出打印项次（…………）；
System.out.println（“类型：文件”）；
System.out.println（“名称：”+entryName）；
zipOutput.putNextEntry（新Zippentry（入口名称））；
字节[]outputByteArray=（（ByteArrayOutputStream）值[1]）。toByteArray（）；
IOUtils.write（outputbytarray，zipOutput）；
zipOutput.closeEntry（）；
（（ByteArrayOutputStream）值[1]）.close（）；
}else if（entry.getKey（）.equals（ZipHandler1.FOLDER））{
系统输出打印项次（…………）；
System.out.println（“类型：文件夹”）；
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.SortedMap;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

import org.apache.commons.lang3.StringUtils;

public class ZipHandler1 {

    private static final int BUFFER_SIZE = 2048;

    private static final String ZIP_EXTENSION = ".zip";
    public static final Integer FOLDER = 1;
    public static final Integer ZIP = 2;
    public static final Integer FILE = 3;


    public static Deque<Map<Integer, Object[]>> unzip(ByteArrayOutputStream zippedOutputFile) {

        try {

            ZipInputStream inputStream = new ZipInputStream(
          new BufferedInputStream(new ByteArrayInputStream(
              zippedOutputFile.toByteArray())));

            ZipEntry entry;

            Deque<Map<Integer, Object[]>> result = new ArrayDeque<Map<Integer, Object[]>>();

            while ((entry = inputStream.getNextEntry()) != null) {

                LinkedHashMap<Integer, Object[]> map = new LinkedHashMap<Integer, Object[]>();
                ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
                System.out.println("\tExtracting entry: " + entry);
                int count;
                byte[] data = new byte[BUFFER_SIZE];
                if (!entry.isDirectory()) {
                    BufferedOutputStream out = new BufferedOutputStream(
          outputStream, BUFFER_SIZE);

                while ((count = inputStream.read(data, 0, BUFFER_SIZE)) != -1) {
                    out.write(data, 0, count);
                }

                out.flush();
                out.close();

                //  recursively unzip files
                if (entry.getName().toUpperCase().endsWith(ZIP_EXTENSION.toUpperCase())) {
                map.put(ZIP, new Object[] {entry.getName(), unzip(outputStream)});
                result.add(map);

                } else { 
                    map.put(FILE, new Object[] {entry.getName(), outputStream});
                    result.add(map);
                }
                } else {
                    map.put(FOLDER, new Object[] {entry.getName(), 
                    unzip(outputStream)});
                    result.add(map);
                }
            }

        inputStream.close();

        return result;

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

package course.hernan;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

import org.apache.commons.io.IOUtils;

public class FileReader {

  private static final int  BUFFER_SIZE = 2048;

  public static void main(String[] args) {

    try {
      File f = new File("DIR/inputs.zip");
      FileInputStream fis = new FileInputStream(f);
      BufferedInputStream bis = new BufferedInputStream(fis);
      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      BufferedOutputStream bos = new BufferedOutputStream(baos);
      byte[] buffer = new byte[BUFFER_SIZE];

      while (bis.read(buffer, 0, BUFFER_SIZE) != -1) {
        bos.write(buffer);
      }

      bos.flush();
      bos.close();
      bis.close();

      Deque<Map<Integer, Object[]>> outputDataStack = ZipHandler1.unzip(baos);

      //Output file
      File fout = new File("DIR/inputs2.zip");

      ZipOutputStream zipOutput = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(fout)));

      processZip(outputDataStack, zipOutput);
      zipOutput.close();

    } catch (FileNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
}

private static final void processZip(Deque<Map<Integer, Object[]>> outputDataStack, 
  ZipOutputStream zipOutput) throws IOException {

while (!outputDataStack.isEmpty()) {
    Map<Integer, Object[]> map = outputDataStack.pop();

    for (Map.Entry<Integer, Object[]> entry : map.entrySet()) {
        System.out.println("KEY:" + entry.getKey());
        Object[] values = entry.getValue();
        String entryName = (String)values[0];

        if (entry.getKey().equals(ZipHandler1.FILE)) {
            System.out.println("..........................");
            System.out.println("type: FILE");
            System.out.println("Name: " + entryName);

            zipOutput.putNextEntry(new ZipEntry(entryName));
            byte[] outputByteArray = ((ByteArrayOutputStream)values[1]).toByteArray();

            IOUtils.write(outputByteArray, zipOutput);
            zipOutput.closeEntry();
            ((ByteArrayOutputStream)values[1]).close();

        } else if (entry.getKey().equals(ZipHandler1.FOLDER)) {
            System.out.println("..........................");
            System.out.println("type: FOLDER");
            System.out.println("Name: " + entryName);

            zipOutput.putNextEntry(new ZipEntry(entryName));
            System.out.println("..........................");
            zipOutput.closeEntry();

        } else if (entry.getKey().equals(ZipHandler1.ZIP)) {
            System.out.println("..........................");
            System.out.println("type: ZIP");
            System.out.println("Name: " + entryName);

            zipOutput.putNextEntry(new ZipEntry(entryName));

            ByteArrayOutputStream innerZipByteArray = new ByteArrayOutputStream(BUFFER_SIZE);
            ZipOutputStream innerZipOutput = new ZipOutputStream(
          new BufferedOutputStream(innerZipByteArray));

            processZip((Deque<Map<Integer,Object[]>>)values[1], innerZipOutput);
            innerZipOutput.flush();
            IOUtils.write(zzzz.toByteArray(), zipOutput);
            innerZipOutput.close();
            zipOutput.closeEntry();
            System.out.println("..........................");
        }
            System.out.println("..........................");
            zipOutput.closeEntry();
        }
    }
}

ZipEntry newEntry = new ZipEntry(entryName);
zipOutput.putNextEntry(newEntry);  

zipOutput.write(innerZipBufferOutputByteArray);

zipOutput.flush();
zipOutput.closeEntry();

ByteArrayOutputStream innerZipBufferOutput = new ByteArrayOutputStream(BUFFER_SIZE);
ZipOutputStream innerZipOutput = new ZipOutputStream(new BufferedOutputStream(innerZipBufferOutput)); 

<<process - e.g. create your inner zip file>>

innerZipOutput.flush();
innerZipOutput.close();

ZipEntry newEntry = new ZipEntry(<<your entry name>>); 

zipOutput.setMethod(ZipOutputStream.STORED);

byte[] innerZipBufferOutputByteArray = innerZipBufferOutput.toByteArray();

//Create the nested ZIP inside the outer ZIP 
ZipEntry newEntry = new ZipEntry(entryName); 
zipOutput.putNextEntry(newEntry);

zipOutput.write(innerZipBufferOutputByteArray);


zipOutput.closeEntry();
zipOutput.close();