别人写的加压

由于频繁需要解压ZIP，加压ZIP


FileItem:


Java代码
    public class FileItem { 
      private String fileName; 
      private byte[] fileContent; 
   
      public String getFileName() { 
           return fileName; 
    } 
      public void setFileName(String fileName) { 
          this.fileName = fileName; 
      } 
   
     public byte[] getFileContent() { 
          return fileContent; 
     } 
   
    public void setFileContent(byte[] fileContent) { 
          this.fileContent = fileContent; 
       } 
  } 



   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.io.InputStream; 
   import java.util.ArrayList; 
  import java.util.List; 
   import java.util.zip.ZipEntry; 
import java.util.zip.ZipInputStream; 
   import java.util.zip.ZipOutputStream; 
   
   public class FileUtil { 
      /**缓存大小*/ 
      private final static int BUFFER_SIZE = 8192; 
       /**后缀名*/ 
       private final static String SUFFIX = "zip"; 
       /**后缀名分隔符*/ 
      private final static String POINT = "."; 
       
//       /**
//  26.      * 获得字节数组
//  27.      * 
//  28.      * @param filepath 文件全路径
//  29.      * @return 字节数组
//  30.      * @throws IOException IOException
//  31.      */ 
        
      public static byte[] getBytes(File file) throws IOException{ 
           return getBytes(file.getAbsolutePath()); 
     }  
      public static byte[] getBytes(String filepath) throws IOException { 
         BufferedInputStream bis = null; 
          ByteArrayOutputStream byteArrayOutputStream = null; 
        BufferedOutputStream bos = null; 
        try { 
            byteArrayOutputStream = new ByteArrayOutputStream(); 
              bis = new BufferedInputStream(new FileInputStream(filepath)); 
              bos = new BufferedOutputStream(byteArrayOutputStream); 
             byte[] bytes = new byte[BUFFER_SIZE]; 
             int len; 
             while ((len = bis.read(bytes, 0, BUFFER_SIZE)) != -1) { 
                bos.write(bytes, 0, len); 
             } 
        } catch (FileNotFoundException e) { 
             e.printStackTrace(); 
              throw e; 
         } catch (IOException e) { 
              e.printStackTrace(); 
             throw e; 
          } finally { 
             if (null != bis) { 
                 try { 
                     bis.close(); 
                  } catch (IOException e) { 
                     e.printStackTrace(); 
                } 
             } 
              if (null != byteArrayOutputStream) { 
                try { 
                    byteArrayOutputStream.close(); 
                 } catch (IOException e) { 
                      e.printStackTrace(); 
                  } 
             } 
              if (null != bos) { 
                 try { 
                      bos.close(); 
                 } catch (IOException e) { 
                      e.printStackTrace(); 
                 } 
            } 
          } 
          return byteArrayOutputStream.toByteArray(); 
      } 
        
//       /**
//  82.      * 统一文件分隔符为LINUX，类UNIX文件系统风格
//  83.      * 
//  84.      * @param direcotory 目录
//  85.      * @return 统一处理后目录字符串风格
//  86.      */ 
       private static String replaceAllSeparator(String direcotory) { 
           String str = direcotory.replaceAll("\\\\", "/"); 
           return str.length() != str.lastIndexOf("/") ? str + "/" : str; 
      } 
        
//  92.     /**
//  93.      * 将文件项写到文件 
//  94.      * 
//  95.      * @param fileItem 文件项
//  96.      * @param directory 目录
//  97.      * @throws IOException IOException
//  98.      */ 
      public static void writeFile(FileItem fileItem, String directory) 
             throws IOException { 
         File dir = new File(directory); 
         if (!dir.exists()) { 
             dir.mkdirs(); 
         } 
        writeFile(fileItem.getFileContent(), replaceAllSeparator(directory) 
                 + fileItem.getFileName()); 
     } 
   
// 109.     /**
// 110.      * 写文件
// 111.      * 
// 112.      * @param fileContent 文件二进制流
// 113.      * @param filepath 文件全路径
// 114.      * @throws IOException IOException 
// 115.      */ 
    public static void writeFile(byte[] fileContent, String filepath) 
            throws IOException { 
        InputStream inputStream = new ByteArrayInputStream(fileContent); 
         writeFile(inputStream, filepath); 
    } 
     
// 122.     /**
// 123.      * 将流写到一个文件
// 124.      * 
// 125.      * @param inputStream 文件流
// 126.      * @param filepath 文件路径
// 127.      * @throws IOException IOException 
// 128.      */ 
     public static void writeFile(InputStream inputStream, String filepath) 
            throws IOException { 
       BufferedOutputStream bos = null; 
         BufferedInputStream bis = null; 
       try { 
             File file = new File(filepath); 
            if (!file.exists()) { 
                file.createNewFile(); 
             } 
            bos = new BufferedOutputStream(new FileOutputStream(file)); 
            bis = new BufferedInputStream(inputStream); 
           byte[] buffer = new byte[BUFFER_SIZE]; 
             int len = -1; 
            while ((len = bis.read(buffer, 0, BUFFER_SIZE)) != -1) { 
                 bos.write(buffer, 0, len); 
             } 
        } catch (IOException e) { 
            e.printStackTrace(); 
            throw e; 
        } finally { 
            if (null != bos) 
               try { 
                    bos.close(); 
                } catch (IOException e) { 
                    e.printStackTrace(); 
               } 
            if (null != bis) 
                try { 
                    bis.close(); 
               } catch (IOException e) { 
                    e.printStackTrace(); 
               } 
        } 
    } 
      
// 164.     /**
// 165.      * 解压zip文件
// 166.      * @param filepath 文件全路径
// 167.      * @return 解压后的文件项
// 168.      * @throws IOException IOException
// 169.      */ 
     public static List uncompressZip(String filepath) throws IOException { 
       ByteArrayOutputStream baos = null; 
         BufferedOutputStream bos = null; 
         ZipInputStream zis = null; 
         // zipInputStream 
        List fileList = null; 
        try { 
            zis = new ZipInputStream(new FileInputStream(filepath)); 
             baos = new ByteArrayOutputStream(); 
             bos = new BufferedOutputStream(baos); 
            fileList = new ArrayList(); 
             byte[] buffer = new byte[BUFFER_SIZE]; 
            int len = -1; 
             ZipEntry zipEntry = null; 
             while (null != (zipEntry = zis.getNextEntry())) { 
                 if (null != zipEntry) { 
                     System.out.println("Name:" + zipEntry.getName() + ",Size:" 
                           + zipEntry.getSize() + "bytes"); 
                   while (-1 != (len = zis.read(buffer))) { 
                          bos.write(buffer, 0, len); 
                     } 
                     bos.flush(); 
                     byte[] fileContent = baos.toByteArray(); 
                   FileItem item = new FileItem(); 
                    item.setFileName(zipEntry.getName()); 
                    item.setFileContent(fileContent); 
                     fileList.add(item); 
                 } 
             } 
         } catch (IOException e) { 
             e.printStackTrace(); 
             throw e; 
         } finally { 
             if (null != zis) { 
                 try { 
                    zis.close(); 
                 } catch (IOException e) { 
                    e.printStackTrace(); 
                 } 
            } 
            if (null != baos) { 
               try { 
                    baos.close(); 
               } catch (IOException e) { 
                     e.printStackTrace(); 
                } 
            } 
             if (null != bos) { 
                  try { 
                     bos.close(); 
                 } catch (IOException e) { 
                    e.printStackTrace(); 
                } 
             } 
         } 
        return fileList; 
      } 
 
// 228.     /**
// 229.      * 将目录压缩成zip包
// 230.      * 
// 231.      * @param filepath
// 232.      *            文件全路径
// 233.      * @throws IOException
// 234.      *             IOException
// 235.      */ 
   public static FileItem compressZip(String filepath) throws IOException { 
        File directory = new File(filepath); 
         String filename = directory.getName(); 
         File[] fileList = directory.listFiles(); 
         ZipOutputStream zos = null; 
        BufferedInputStream bis = null; 
          ByteArrayOutputStream baos = null; 
        FileItem fileItem = null; 
         try { 
             baos = new ByteArrayOutputStream(); 
            zos = new ZipOutputStream(baos); 
             byte[] buffer = new byte[BUFFER_SIZE]; 
            int len = -1; 
             for (File file : fileList) { 
                 bis = new BufferedInputStream(new FileInputStream(file)); 
                 while (-1 != (len = bis.read(buffer, 0, BUFFER_SIZE))) { 
                    //ZipEntry为Zip压缩文件的每一项 
                    ZipEntry zipEntry = new ZipEntry(file.getName()); 
                    zipEntry.setSize(file.length()); 
                     zipEntry.setCompressedSize(file.length()); 
                    zos.putNextEntry(zipEntry); 
                    zos.write(buffer, 0, len); 
                } 
                //做完一个文件的读写应清下缓存 
                 zos.flush(); 
                 if (null != bis) { 
                     bis.close(); 
                 } 
              } 
             //完成所有文件的读取,转化为一个二进制流的包装zos 
             zos.finish(); 
             fileItem = new FileItem(); 
            int index = filename.lastIndexOf("."); 
            filename = filename.substring(0, -1 == index ? filename.length() 
                     : index); 
             //要生成zip文件的文件名 
             fileItem.setFileName(filename + POINT + SUFFIX); 
             //要生成的zip文件的二进制流 
             fileItem.setFileContent(baos.toByteArray()); 
        } catch (IOException e) { 
              e.printStackTrace(); 
             throw e; 
         } finally { 
            if (null != baos) { 
                try { 
                    baos.close(); 
                } catch (IOException e) { 
                     e.printStackTrace(); 
                  } 
            } 
            if (null != bis) { 
                 try { 
                   bis.close(); 
                } catch (IOException e) { 
                      e.printStackTrace(); 
                  } 
              } 
             if (null != zos) { 
                try { 
                     zos.close(); 
                 } catch (IOException e) { 
                     e.printStackTrace(); 
                 } 
             } 
         } 
          return fileItem; 
      } 
  
     /**
      * 解压zip文件
       * 
       * @param zipFile zip文件
      * @return 解压后的文件项
     * @throws IOException IOException
     */ 
    public static List uncompressZip(File zipFile) throws IOException { 
        String filepath = zipFile.getAbsolutePath(); 
        return uncompressZip(filepath); 
      } 
  
    public static void main(String[] args) throws IOException { 
         //加压 
         FileItem fileItem = compressZip("F:/aa"); 
         //将SCYSB_1234567890_0901_20100912082719250.zip文件写到F:/zjie目录 
         FileUtil.writeFile(fileItem, "F:/zjie"); 
        //解压F:/zjie/SCYSB_1234567890_0901_20100912082719250.zip文件 
          List fileItemList = FileUtil 
               .uncompressZip("F:/zjie/aa.zip"); 
          //将解压后的文件流生成文件写到F:/zjie/SCYSB_1234567890_0901_20100912082719250/目录 
         for (int i = 0; i < fileItemList.size(); i++) { 
            FileItem item = (FileItem) fileItemList.get(i); 
//            DbfUtil.dbfReader(item.getFileContent()); 
             FileUtil.writeFile(item.getFileContent(), "F:/zjie/SCYSB_1234567890_0901_20100912082719250/"+item.getFileName()); 
          } 
          
     } 
  }