說明：

1、一般來說要實現壓縮，那麽返回方式一般是用byte[]數組。

2、研究發現byte[]數組在轉成可讀的String時，大小會還原回原來的。

3、如果采用壓縮之後不可讀的String時，互相轉換大小會變小，唯一缺點就是轉出的String不可讀，需要再次解碼之後才可讀。

4、對於壓縮一般最近常聽的應該就是gzip這些。

實現一：

/***
  * 壓縮GZip
  * 
  * @param data
  * @return
  */
 public static byte[] gZip(byte[] data) {
  byte[] b = null;
  
 
try {
   ByteArrayOutputStream bos = new ByteArrayOutputStream();
   GZIPOutputStream gzip = new GZIPOutputStream(bos);
   gzip.write(data);
   gzip.finish();
   gzip.close();
   b = bos.toByteArray();
   bos.close();
  } catch (Exception ex) {
   ex.printStackTrace();
  }
  return b;
 }

 
/***
  * 解壓GZip
  * 
  * @param data
  * @return
  */
 public static byte[] unGZip(byte[] data) {
  byte[] b = null;
  try {
   ByteArrayInputStream bis = new ByteArrayInputStream(data);
   GZIPInputStream gzip = new GZIPInputStream(bis);
   byte[] buf = new byte[1024];
   int num = -1;
   ByteArrayOutputStream baos 
 
= new ByteArrayOutputStream();
   while ((num = gzip.read(buf, 0, buf.length)) != -1) {
    baos.write(buf, 0, num);
   }
   b = baos.toByteArray();
   baos.flush();
   baos.close();
   gzip.close();
   bis.close();
  } catch (Exception ex) {
   ex.printStackTrace();
  }
  return b;
 }



/***
  * 壓縮Zip
  * 
  * @param data
  * @return
  */
 public static byte[] zip(byte[] data) {
  byte[] b = null;
  try {
   ByteArrayOutputStream bos = new ByteArrayOutputStream();
   ZipOutputStream zip = new ZipOutputStream(bos);
   ZipEntry entry = new ZipEntry("zip");
   entry.setSize(data.length);
   zip.putNextEntry(entry);
   zip.write(data);
   zip.closeEntry();
   zip.close();
   b = bos.toByteArray();
   bos.close();
  } catch (Exception ex) {
   ex.printStackTrace();
  }
  return b;
 }

/***
  * 解壓Zip
  * 
  * @param data
  * @return
  */
 public static byte[] unZip(byte[] data) {
  byte[] b = null;
  try {
   ByteArrayInputStream bis = new ByteArrayInputStream(data);
   ZipInputStream zip = new ZipInputStream(bis);
   while (zip.getNextEntry() != null) {
    byte[] buf = new byte[1024];
    int num = -1;
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    while ((num = zip.read(buf, 0, buf.length)) != -1) {
     baos.write(buf, 0, num);
    }
    b = baos.toByteArray();
    baos.flush();
    baos.close();
   }
   zip.close();
   bis.close();
  } catch (Exception ex) {
   ex.printStackTrace();
  }
  return b;
 }

/***
  * 壓縮BZip2
  * 
  * @param data
  * @return
  */
 public static byte[] bZip2(byte[] data) {
  byte[] b = null;
  try {
   ByteArrayOutputStream bos = new ByteArrayOutputStream();
   CBZip2OutputStream bzip2 = new CBZip2OutputStream(bos);
   bzip2.write(data);
   bzip2.flush();
   bzip2.close();
   b = bos.toByteArray();
   bos.close();
  } catch (Exception ex) {
   ex.printStackTrace();
  }
  return b;
 }

 /***
  * 解壓BZip2
  * 
  * @param data
  * @return
  */
 public static byte[] unBZip2(byte[] data) {
  byte[] b = null;
  try {
   ByteArrayInputStream bis = new ByteArrayInputStream(data);
   CBZip2InputStream bzip2 = new CBZip2InputStream(bis);
   byte[] buf = new byte[1024];
   int num = -1;
   ByteArrayOutputStream baos = new ByteArrayOutputStream();
   while ((num = bzip2.read(buf, 0, buf.length)) != -1) {
    baos.write(buf, 0, num);
   }
   b = baos.toByteArray();
   baos.flush();
   baos.close();
   bzip2.close();
   bis.close();
  } catch (Exception ex) {
   ex.printStackTrace();
  }
  return b;
 }

/**
  * 把字節數組轉換成16進制字符串
  * 
  * @param bArray
  * @return
  */
 public static String bytesToHexString(byte[] bArray) {
  StringBuffer sb = new StringBuffer(bArray.length);
  String sTemp;
  for (int i = 0; i < bArray.length; i++) {
   sTemp = Integer.toHexString(0xFF & bArray[i]);
   if (sTemp.length() < 2)
    sb.append(0);
   sb.append(sTemp.toUpperCase());
  }
  return sb.toString();
 }


/**
  *jzlib 壓縮數據
  * 
  * @param object
  * @return
  * @throws IOException
  */
 public static byte[] jzlib(byte[] object) {
  byte[] data = null;
  try {
   ByteArrayOutputStream out = new ByteArrayOutputStream();
   ZOutputStream zOut = new ZOutputStream(out,
     JZlib.Z_DEFAULT_COMPRESSION);
   DataOutputStream objOut = new DataOutputStream(zOut);
   objOut.write(object);
   objOut.flush();
   zOut.close();
   data = out.toByteArray();
   out.close();
  } catch (IOException e) {
   e.printStackTrace();
  }
  return data;
 }
 /**
  *jzLib壓縮的數據
  * 
  * @param object
  * @return
  * @throws IOException
  */
 public static byte[] unjzlib(byte[] object) {
  byte[] data = null;
  try {
   ByteArrayInputStream in = new ByteArrayInputStream(object);
   ZInputStream zIn = new ZInputStream(in);
   byte[] buf = new byte[1024];
   int num = -1;
   ByteArrayOutputStream baos = new ByteArrayOutputStream();
   while ((num = zIn.read(buf, 0, buf.length)) != -1) {
    baos.write(buf, 0, num);
   }
   data = baos.toByteArray();
   baos.flush();
   baos.close();
   zIn.close();
   in.close();
   
  } catch (IOException e) {
   e.printStackTrace();
  }
  return data;
 }
 public static void main(String[] args) {
  String s = "this is a test";
  
  byte[] b1 = zip(s.getBytes());
  System.out.println("zip:" + bytesToHexString(b1));
  byte[] b2 = unZip(b1);
  System.out.println("unZip:" + new String(b2));
  byte[] b3 = bZip2(s.getBytes());
  System.out.println("bZip2:" + bytesToHexString(b3));
  byte[] b4 = unBZip2(b3);
  System.out.println("unBZip2:" + new String(b4));
  byte[] b5 = gZip(s.getBytes());
  System.out.println("bZip2:" + bytesToHexString(b5));
  byte[] b6 = unGZip(b5);
  System.out.println("unBZip2:" + new String(b6));
  byte[] b7 = jzlib(s.getBytes());
  System.out.println("jzlib:" + bytesToHexString(b7));
  byte[] b8 = unjzlib(b7);
  System.out.println("unjzlib:" + new String(b8));
 }
}

實現二：

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;

// 將一個字符串按照zip方式壓縮和解壓縮
public class ZipUtil {

  // 壓縮
  public static String compress(String str) throws IOException {
    if (str == null || str.length() == 0) {
      return str;
    }
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    GZIPOutputStream gzip = new GZIPOutputStream(out);
    gzip.write(str.getBytes());
    gzip.close();
    return out.toString("ISO-8859-1");
  }

  // 解壓縮
  public static String uncompress(String str) throws IOException {
    if (str == null || str.length() == 0) {
      return str;
    }
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    ByteArrayInputStream in = new ByteArrayInputStream(str
        .getBytes("ISO-8859-1"));
    GZIPInputStream gunzip = new GZIPInputStream(in);
    byte[] buffer = new byte[256];
    int n;
    while ((n = gunzip.read(buffer)) >= 0) {
      out.write(buffer, 0, n);
    }
    // toString()使用平臺默認編碼，也可以顯式的指定如toString("GBK")
    return out.toString();
  }

  // 測試方法
  public static void main(String[] args) throws IOException {
    System.out.println(ZipUtil.uncompress(ZipUtil.compress("中國China")));
  }

}

實現三：

import java.io.ByteArrayInputStream;    
import java.io.ByteArrayOutputStream;    
import java.io.IOException;    
import java.util.zip.ZipEntry;    
import java.util.zip.ZipInputStream;    
import java.util.zip.ZipOutputStream;    
    
public class StringCompress {    
    public static final byte[] compress(String paramString) {    
        if (paramString == null)    
            return null;    
        ByteArrayOutputStream byteArrayOutputStream = null;    
        ZipOutputStream zipOutputStream = null;    
        byte[] arrayOfByte;    
        try {    
            byteArrayOutputStream = new ByteArrayOutputStream();    
            zipOutputStream = new ZipOutputStream(byteArrayOutputStream);    
            zipOutputStream.putNextEntry(new ZipEntry("0"));    
            zipOutputStream.write(paramString.getBytes());    
            zipOutputStream.closeEntry();    
            arrayOfByte = byteArrayOutputStream.toByteArray();    
        } catch (IOException localIOException5) {    
            arrayOfByte = null;    
        } finally {    
            if (zipOutputStream != null)    
                try {    
                    zipOutputStream.close();    
                } catch (IOException localIOException6) {    
            }    
            if (byteArrayOutputStream != null)    
                try {    
                    byteArrayOutputStream.close();    
                } catch (IOException localIOException7) {    
            }    
        }    
        return arrayOfByte;    
    }    
    
    @SuppressWarnings("unused")    
    public static final String decompress(byte[] paramArrayOfByte) {    
        if (paramArrayOfByte == null)    
            return null;    
        ByteArrayOutputStream byteArrayOutputStream = null;    
        ByteArrayInputStream byteArrayInputStream = null;    
        ZipInputStream zipInputStream = null;    
        String str;    
        try {    
            byteArrayOutputStream = new ByteArrayOutputStream();    
            byteArrayInputStream = new ByteArrayInputStream(paramArrayOfByte);    
            zipInputStream = new ZipInputStream(byteArrayInputStream);    
            ZipEntry localZipEntry = zipInputStream.getNextEntry();    
            byte[] arrayOfByte = new byte[1024];    
            int i = -1;    
            while ((i = zipInputStream.read(arrayOfByte)) != -1)    
                byteArrayOutputStream.write(arrayOfByte, 0, i);    
            str = byteArrayOutputStream.toString();    
        } catch (IOException localIOException7) {    
            str = null;    
        } finally {    
            if (zipInputStream != null)    
                try {    
                    zipInputStream.close();    
                } catch (IOException localIOException8) {    
                }    
            if (byteArrayInputStream != null)    
                try {    
                    byteArrayInputStream.close();    
                } catch (IOException localIOException9) {    
                }    
            if (byteArrayOutputStream != null)    
                try {    
                    byteArrayOutputStream.close();    
                } catch (IOException localIOException10) {    
            }    
        }    
        return str;    
    }    
}    

參考：

https://www.cnblogs.com/dongzhongwei/p/5964758.html（以上內容部分轉自此篇文章）

http://www.blogjava.net/fastunit/archive/2008/04/25/195932.html（以上內容部分轉自此篇文章）

http://blog.csdn.net/xyw591238/article/details/51720016（以上內容部分轉自此篇文章）

Java壓縮字符串的方法收集