content: /**
    * Copyright 2017 JessYan
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
    *
    * Unless required by applicable law or agreed to in writing, software
    * distributed under the License is distributed on an "AS IS" BASIS,
    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    * See the License for the specific language governing permissions and
    * limitations under the License.
    */
  package <%= appPackage %>.utils;
  
  import java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.Closeable;
  import java.io.IOException;
  import java.io.UnsupportedEncodingException;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.zip.DataFormatException;
  import java.util.zip.Deflater;
  import java.util.zip.GZIPInputStream;
  import java.util.zip.GZIPOutputStream;
  import java.util.zip.Inflater;
  
  /**
   * ================================================
   * 处理压缩和解压的工具类
   * <p>
   * Created by JessYan on 10/05/2016
   * <a href="mailto:jess.yan.effort@gmail.com">Contact me</a>
   * <a href="https://github.com/JessYanCoding">Follow me</a>
   * ================================================
   */
  public class ZipHelper {
  
  
      private ZipHelper() {
          throw new IllegalStateException("you can't instantiate me!");
      }
  
      /**
       * zlib decompress 2 String
       *
       * @param bytesToDecompress
       * @return
       */
      public static String decompressToStringForZlib(byte[] bytesToDecompress) {
          return decompressToStringForZlib(bytesToDecompress, "UTF-8");
      }
  
  
      /**
       * zlib decompress 2 String
       *
       * @param bytesToDecompress
       * @param charsetName
       * @return
       */
      public static String decompressToStringForZlib(byte[] bytesToDecompress, String charsetName) {
          byte[] bytesDecompressed = decompressForZlib
                  (
                          bytesToDecompress
                  );
  
          String returnValue = null;
  
          try {
              returnValue = new String
                      (
                              bytesDecompressed,
                              0,
                              bytesDecompressed.length,
                              charsetName
                      );
          } catch (UnsupportedEncodingException uee) {
              uee.printStackTrace();
          }
  
          return returnValue;
  
      }
  
  
      /**
       * zlib decompress 2 byte
       *
       * @param bytesToDecompress
       * @return
       */
      public static byte[] decompressForZlib(byte[] bytesToDecompress) {
          byte[] returnValues = null;
  
          Inflater inflater = new Inflater();
  
          int numberOfBytesToDecompress = bytesToDecompress.length;
  
          inflater.setInput
                  (
                          bytesToDecompress,
                          0,
                          numberOfBytesToDecompress
                  );
  
          int bufferSizeInBytes = numberOfBytesToDecompress;
  
          int numberOfBytesDecompressedSoFar = 0;
          List<Byte> bytesDecompressedSoFar = new ArrayList<Byte>();
  
          try {
              while (inflater.needsInput() == false) {
                  byte[] bytesDecompressedBuffer = new byte[bufferSizeInBytes];
  
                  int numberOfBytesDecompressedThisTime = inflater.inflate
                          (
                                  bytesDecompressedBuffer
                          );
  
                  numberOfBytesDecompressedSoFar += numberOfBytesDecompressedThisTime;
  
                  for (int b = 0; b < numberOfBytesDecompressedThisTime; b++) {
                      bytesDecompressedSoFar.add(bytesDecompressedBuffer[b]);
                  }
              }
  
              returnValues = new byte[bytesDecompressedSoFar.size()];
              for (int b = 0; b < returnValues.length; b++) {
                  returnValues[b] = (byte) (bytesDecompressedSoFar.get(b));
              }
  
          } catch (DataFormatException dfe) {
              dfe.printStackTrace();
          }
  
          inflater.end();
  
          return returnValues;
      }
  
      /**
       * zlib compress 2 byte
       *
       * @param bytesToCompress
       * @return
       */
      public static byte[] compressForZlib(byte[] bytesToCompress) {
          Deflater deflater = new Deflater();
          deflater.setInput(bytesToCompress);
          deflater.finish();
  
          byte[] bytesCompressed = new byte[Short.MAX_VALUE];
  
          int numberOfBytesAfterCompression = deflater.deflate(bytesCompressed);
  
          byte[] returnValues = new byte[numberOfBytesAfterCompression];
  
          System.arraycopy
                  (
                          bytesCompressed,
                          0,
                          returnValues,
                          0,
                          numberOfBytesAfterCompression
                  );
  
          return returnValues;
      }
  
      /**
       * zlib compress 2 byte
       *
       * @param stringToCompress
       * @return
       */
      public static byte[] compressForZlib(String stringToCompress) {
          byte[] returnValues = null;
  
          try {
  
              returnValues = compressForZlib
                      (
                              stringToCompress.getBytes("UTF-8")
                      );
          } catch (UnsupportedEncodingException uee) {
              uee.printStackTrace();
          }
  
          return returnValues;
      }
  
      /**
       * gzip compress 2 byte
       *
       * @param string
       * @return
       * @throws IOException
       */
      public static byte[] compressForGzip(String string) {
          ByteArrayOutputStream os = null;
          GZIPOutputStream gos = null;
          try {
              os = new ByteArrayOutputStream(string.length());
              gos = new GZIPOutputStream(os);
              gos.write(string.getBytes("UTF-8"));
              byte[] compressed = os.toByteArray();
              return compressed;
          } catch (IOException e) {
              e.printStackTrace();
          } finally {
              closeQuietly(gos);
              closeQuietly(os);
          }
          return null;
      }
  
      /**
       * gzip decompress 2 string
       *
       * @param compressed
       * @return
       * @throws IOException
       */
      public static String decompressForGzip(byte[] compressed) {
          return decompressForGzip(compressed, "UTF-8");
      }
  
      /**
       * gzip decompress 2 string
       *
       * @param compressed
       * @param charsetName
       * @return
       */
      public static String decompressForGzip(byte[] compressed, String charsetName) {
          final int BUFFER_SIZE = compressed.length;
          GZIPInputStream gis = null;
          ByteArrayInputStream is = null;
          try {
              is = new ByteArrayInputStream(compressed);
              gis = new GZIPInputStream(is, BUFFER_SIZE);
              StringBuilder string = new StringBuilder();
              byte[] data = new byte[BUFFER_SIZE];
              int bytesRead;
              while ((bytesRead = gis.read(data)) != -1) {
                  string.append(new String(data, 0, bytesRead, charsetName));
              }
              return string.toString();
          } catch (IOException e) {
              e.printStackTrace();
          } finally {
              closeQuietly(gis);
              closeQuietly(is);
          }
          return null;
      }
  
      public static void closeQuietly(Closeable closeable) {
          if (closeable != null) {
              try {
                  closeable.close();
              } catch (RuntimeException rethrown) {
                  throw rethrown;
              } catch (Exception ignored) {
              }
          }
      }
  }
  