public static ByteBuffer doDecompress(ByteBuffer buffer, int length) { byte[] byteArrayIn = new byte[1024]; ByteArrayInputStream byteIn; if (buffer.hasArray()) { byteIn = new ByteArrayInputStream( buffer.array(), buffer.position() + buffer.arrayOffset(), buffer.remaining()); } else { byte[] array = new byte[buffer.limit() - buffer.position()]; buffer.get(array); byteIn = new ByteArrayInputStream(array); } ByteBuffer retBuff = ByteBuffer.allocate(length); int len = 0; try { GZIPInputStream in = new GZIPInputStream(byteIn); while ((len = in.read(byteArrayIn)) > 0) { retBuff.put(byteArrayIn, 0, len); } in.close(); } catch (IOException e) { s_logger.error("Fail to decompress the request!", e); } retBuff.flip(); return retBuff; }
@Override public String getData() { if (httpMessage == null) { return ""; } if (HttpHeader.GZIP.equals( httpMessage.getResponseHeader().getHeader(HttpHeader.CONTENT_ENCODING))) { // Uncompress gziped content try { ByteArrayInputStream bais = new ByteArrayInputStream(httpMessage.getResponseBody().getBytes()); GZIPInputStream gis = new GZIPInputStream(bais); InputStreamReader isr = new InputStreamReader(gis); BufferedReader br = new BufferedReader(isr); StringBuilder sb = new StringBuilder(); String line = null; while ((line = br.readLine()) != null) { sb.append(line); } br.close(); isr.close(); gis.close(); bais.close(); return sb.toString(); } catch (IOException e) { // this.log.error(e.getMessage(), e); System.out.println(e); } } return httpMessage.getResponseBody().toString(); }
public byte[] handleResponse(HttpResponse hr) throws ClientProtocolException, IOException { if (hr.getStatusLine().getStatusCode() == 200) { if (hr.getEntity().getContentEncoding() == null) { return EntityUtils.toByteArray(hr.getEntity()); } if (hr.getEntity().getContentEncoding().getValue().contains("gzip")) { GZIPInputStream gis = null; try { gis = new GZIPInputStream(hr.getEntity().getContent()); ByteArrayOutputStream baos = new ByteArrayOutputStream(); byte[] b = new byte[1024]; int n; while ((n = gis.read(b)) != -1) baos.write(b, 0, n); System.out.println("Gzipped"); return baos.toByteArray(); } catch (IOException e) { throw e; } finally { try { if (gis != null) gis.close(); } catch (IOException ex) { throw ex; } } } return EntityUtils.toByteArray(hr.getEntity()); } if (hr.getStatusLine().getStatusCode() == 302) { throw new IOException("302"); } return null; }
@Override public String getResponseBodyAsString() throws IOException { GZIPInputStream gzin; if (getResponseBody() != null || getResponseStream() != null) { if (getResponseHeader("Content-Encoding") != null && getResponseHeader("Content-Encoding").getValue().toLowerCase().indexOf("gzip") > -1) { // For GZip response InputStream is = getResponseBodyAsStream(); gzin = new GZIPInputStream(is); InputStreamReader isr = new InputStreamReader(gzin, getResponseCharSet()); java.io.BufferedReader br = new java.io.BufferedReader(isr); StringBuffer sb = new StringBuffer(); String tempbf; while ((tempbf = br.readLine()) != null) { sb.append(tempbf); sb.append("\r\n"); } isr.close(); gzin.close(); return sb.toString(); } else { // For deflate response return super.getResponseBodyAsString(); } } else { return null; } }
@Test public void testJavaDataApiUtils() throws InvalidReferenceException, DataTransferException, IOException { JavaDataApiUtils util = new JavaDataApiUtils(service); String dfid = "URN:LSID:caarray.nci.nih.gov:gov.nih.nci.caarray.external.v1_0.data.File:1"; CaArrayEntityReference fileRef = new CaArrayEntityReference(dfid); ByteArrayOutputStream stream = new ByteArrayOutputStream(); // test gziped util.copyFileContentsToOutputStream(fileRef, true, stream); ByteArrayInputStream in = new ByteArrayInputStream(stream.toByteArray()); GZIPInputStream zin = new GZIPInputStream(in); assertFalse(-1 == zin.read()); // test non gzip stream.reset(); util.copyFileContentsToOutputStream(fileRef, false, stream); in = new ByteArrayInputStream(stream.toByteArray()); try { zin = new GZIPInputStream(in); zin.read(); fail("expected an IOException"); } catch (IOException e) { assertEquals("Not in GZIP format", e.getMessage()); } }
@SuppressWarnings("unchecked") private HashMap<String, Integer> loadWinPoints() { String filename = "winpoints"; HashMap<String, Integer> out = null; if (!new File(pl.getDataFolder(), filename).exists()) { HashMap<String, Integer> newHM = new HashMap<String, Integer>(); saveWinPoints(newHM); } try { FileInputStream fin = new FileInputStream(new File(pl.getDataFolder(), filename)); GZIPInputStream gzin = new GZIPInputStream(fin); ObjectInputStream in = new ObjectInputStream(gzin); Object o = in.readObject(); if (!(o instanceof HashMap<?, ?>)) { pl.getLogger().severe("Fatal Error! Winpoints file was corrupted!"); out = new HashMap<String, Integer>(); } else { out = (HashMap<String, Integer>) o; } in.close(); gzin.close(); fin.close(); } catch (Exception e) { e.printStackTrace(); } return out; }
protected void setResult(HttpURLConnection conn, ByteArrayOutputStream output) throws IOException { setResponseHeader(conn); byte[] ret = output.toByteArray(); // 没有数据返回 if (ret == null || ret.length == 0) { responseData = null; return; } final HashMap<String, String> mResponseHeader = getResponseHeader(); if (null != mResponseHeader) { String encode = mResponseHeader.get("content-encoding"); if (null != encode && encode.contains("gzip")) { ByteArrayInputStream input = new ByteArrayInputStream(ret); ByteArrayOutputStream tmpOutput = new ByteArrayOutputStream(BUFFERSIZE); GZIPInputStream gin = new GZIPInputStream(input); int count; byte data[] = new byte[BUFFERSIZE]; while ((count = gin.read(data, 0, BUFFERSIZE)) != -1) { tmpOutput.write(data, 0, count); } gin.close(); ret = tmpOutput.toByteArray(); } } responseData = ret; }
/** * Decodes data from Base64 notation, automatically detecting gzip-compressed data and * decompressing it. * * @param s the string to decode * @return the decoded data * @since 1.4 */ public static byte[] decode(String s) { byte[] bytes; try { bytes = s.getBytes(PREFERRED_ENCODING); } // end try catch (java.io.UnsupportedEncodingException uee) { bytes = s.getBytes(); } // end catch // </change> // Decode bytes = decode(bytes, 0, bytes.length); // Check to see if it's gzip-compressed // GZIP Magic Two-Byte Number: 0x8b1f (35615) if (bytes != null && bytes.length >= 4) { int head = ((int) bytes[0] & 0xff) | ((bytes[1] << 8) & 0xff00); if (java.util.zip.GZIPInputStream.GZIP_MAGIC == head) { java.io.ByteArrayInputStream bais = null; java.util.zip.GZIPInputStream gzis = null; java.io.ByteArrayOutputStream baos = null; byte[] buffer = new byte[2048]; int length = 0; try { baos = new java.io.ByteArrayOutputStream(); bais = new java.io.ByteArrayInputStream(bytes); gzis = new java.util.zip.GZIPInputStream(bais); while ((length = gzis.read(buffer)) >= 0) { baos.write(buffer, 0, length); } // end while: reading input // No error? Get new bytes. bytes = baos.toByteArray(); } // end try catch (java.io.IOException e) { // Just return originally-decoded bytes } // end catch finally { try { baos.close(); } catch (Exception e) { } try { gzis.close(); } catch (Exception e) { } try { bais.close(); } catch (Exception e) { } } // end finally } // end if: gzipped } // end if: bytes.length >= 2 return bytes; } // end decode
public static String unGzipBytesToString(InputStream in) { try { PushbackInputStream pis = new PushbackInputStream(in, 2); byte[] signature = new byte[2]; pis.read(signature); pis.unread(signature); int head = ((signature[0] & 0x00FF) | ((signature[1] << 8) & 0xFF00)); if (head != GZIPInputStream.GZIP_MAGIC) { return new String(toByteArray(pis), "UTF-8").trim(); } GZIPInputStream gzip = new GZIPInputStream(pis); byte[] readBuf = new byte[8 * 1024]; ByteArrayOutputStream outputByte = new ByteArrayOutputStream(); int readCount = 0; do { readCount = gzip.read(readBuf); if (readCount > 0) { outputByte.write(readBuf, 0, readCount); } } while (readCount > 0); closeQuietly(gzip); closeQuietly(pis); closeQuietly(in); if (outputByte.size() > 0) { return new String(outputByte.toByteArray(), "UTF-8"); } } catch (Exception e) { e.printStackTrace(); } return null; }
@SuppressWarnings("unused") private String unzipBody(InputStream str) { InputStreamReader sr = null; StringWriter writer = null; GZIPInputStream gis = null; try { char[] buffer = new char[10240]; gis = new GZIPInputStream(str); sr = new InputStreamReader(gis, "UTF-8"); writer = new StringWriter(); for (int i = 0; (i = sr.read(buffer)) > 0; ) { writer.write(buffer, 0, i); } return writer.toString(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } finally { try { if (writer != null) writer.close(); if (sr != null) sr.close(); if (gis != null) gis.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } return null; }
@Override public PointSet load(String pointSetId) throws Exception { File cachedFile; if (!workOffline) { // get pointset metadata from S3 cachedFile = new File(POINT_DIR, pointSetId + ".json"); if (!cachedFile.exists()) { POINT_DIR.mkdirs(); S3Object obj = s3.getObject(pointsetBucket, pointSetId + ".json.gz"); ObjectMetadata objMet = obj.getObjectMetadata(); FileOutputStream fos = new FileOutputStream(cachedFile); GZIPInputStream gis = new GZIPInputStream(obj.getObjectContent()); try { ByteStreams.copy(gis, fos); } finally { fos.close(); gis.close(); } } } else cachedFile = new File(POINT_DIR, pointSetId + ".json"); // grab it from the cache return PointSet.fromGeoJson(cachedFile); }
/** * gzip 解壓縮 * * @param value * @return */ public static byte[] ungzip(byte[] value) { byte[] result = new byte[0]; ByteArrayInputStream in = null; GZIPInputStream gin = null; ByteArrayOutputStream out = null; try { // in = new ByteArrayInputStream(value); gin = new GZIPInputStream(in, BUFFER_LENGTH); out = new ByteArrayOutputStream(); // byte[] buff = new byte[BUFFER_LENGTH]; int read = 0; while ((read = gin.read(buff)) > -1) { out.write(buff, 0, read); } // result = out.toByteArray(); } catch (Exception ex) { ex.printStackTrace(); } finally { IoHelper.close(in); IoHelper.close(gin); IoHelper.close(out); } return result; }
public void WritingToUnzippedFile(String fileName) throws IOException { // open the input (compressed) file. FileInputStream stream = new FileInputStream(fileName); FileOutputStream output = null; try { // open the gziped file to decompress. GZIPInputStream gzipstream = new GZIPInputStream(stream); byte[] buffer = new byte[2048]; // create the output file without the .gz extension. String outname = fileName.substring(0, fileName.length() - 3); output = new FileOutputStream(outname); // and copy it to a new file int len; while ((len = gzipstream.read(buffer)) > 0) { output.write(buffer, 0, len); } } finally { // both streams must always be closed. if (output != null) output.close(); stream.close(); } }
/** * Ctor. * * @param sz The filename. */ public gunzip(String sz) { String zipname, source; if (sz.toLowerCase().endsWith(".gz")) { zipname = sz; source = zipname.substring(0, zipname.length() - 3); } else { zipname = sz + ".gz"; source = sz; } GZIPInputStream gzis = null; OutputStream fos = null; try { gzis = new GZIPInputStream(new FileInputStream(zipname)); fos = new FileOutputStream(source); byte[] buffer = new byte[BLOCKSIZE]; for (int length; (length = gzis.read(buffer, 0, BLOCKSIZE)) != -1; ) fos.write(buffer, 0, length); } catch (IOException e) { System.out.println("Error: Couldn't decompress " + sz); } finally { if (fos != null) try { fos.close(); } catch (IOException e) { e.printStackTrace(); } if (gzis != null) try { gzis.close(); } catch (IOException e) { e.printStackTrace(); } } }
/** * Returns an gunzipped copy of the input array, truncated to <code>sizeLimit</code> bytes, if * necessary. If the gzipped input has been truncated or corrupted, a best-effort attempt is made * to unzip as much as possible. If no data can be extracted <code>null</code> is returned. */ public static final byte[] unzipBestEffort(byte[] in, int sizeLimit) { try { // decompress using GZIPInputStream ByteArrayOutputStream outStream = new ByteArrayOutputStream(EXPECTED_COMPRESSION_RATIO * in.length); GZIPInputStream inStream = new GZIPInputStream(new ByteArrayInputStream(in)); byte[] buf = new byte[BUF_SIZE]; int written = 0; while (true) { try { int size = inStream.read(buf); if (size <= 0) break; if ((written + size) > sizeLimit) { outStream.write(buf, 0, sizeLimit - written); break; } outStream.write(buf, 0, size); written += size; } catch (Exception e) { break; } } try { outStream.close(); } catch (IOException e) { } return outStream.toByteArray(); } catch (IOException e) { return null; } }
public static void unZip(String inputFile) { // inputFile = inputFile.substring(0, inputFile.length() - 3); try { String inFilename = inputFile; System.out.println("Opening the gzip file........ .................. : opened"); GZIPInputStream gzipInputStream = null; FileInputStream fileInputStream = null; gzipInputStream = new GZIPInputStream(new FileInputStream(inFilename)); System.out.println("Opening the output file.. ........... : opened"); String outFilename = inFilename + ".out"; OutputStream out = new FileOutputStream(outFilename); System.out.println( "Transferring bytes from the compressed file to the output file........: Transfer successful"); byte[] buf = new byte[1024]; // size can be changed according to programmer's need. int len; while ((len = gzipInputStream.read(buf)) != -1) { out.write(buf, 0, len); } gzipInputStream.close(); out.close(); } catch (IOException e) { System.out.println("Exception has been thrown" + e); } }
public byte[] decompress(byte[] buffer) throws IOException { ByteArrayInputStream inputStream = new ByteArrayInputStream(buffer); // Open the compressed stream GZIPInputStream gzip = new GZIPInputStream(inputStream); ByteArrayOutputStream out = new ByteArrayOutputStream(); try { // Transfer bytes from the compressed stream to the output stream byte[] buf = new byte[unit]; int len; while ((len = gzip.read(buf)) > 0) { out.write(buf, 0, len); } return out.toByteArray(); } catch (IOException e) { throw e; } finally { // Close the file and stream gzip.close(); out.close(); inputStream.close(); } }
public static ExpandedResult processGzipEncoded(byte[] compressed, int sizeLimit) throws IOException { ByteArrayOutputStream outStream = new ByteArrayOutputStream(EXPECTED_GZIP_COMPRESSION_RATIO * compressed.length); GZIPInputStream inStream = new GZIPInputStream(new ByteArrayInputStream(compressed)); boolean isTruncated = false; byte[] buf = new byte[BUF_SIZE]; int written = 0; while (true) { try { int size = inStream.read(buf); if (size == -1) { break; } if ((written + size) > sizeLimit) { isTruncated = true; outStream.write(buf, 0, sizeLimit - written); break; } outStream.write(buf, 0, size); written += size; } catch (Exception e) { LOGGER.trace("Exception unzipping content", e); break; } } IoUtils.safeClose(outStream); return new ExpandedResult(outStream.toByteArray(), isTruncated); }
@Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { byte[] body = "gzip gzip gzip gzip gzip gzip gzip gzip gzip gzip gzip gzip gzip gzip gzip gzip gzip gzip gzip gzip gzip gzip gzip " .getBytes("UTF-8"); resp.setStatus(HttpServletResponse.SC_OK); if (containsHeader(req, "Content-Encoding", "gzip")) { GZIPInputStream gzipInputStream = new GZIPInputStream(req.getInputStream()); ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); int byteCount = 0; byte[] buffer = new byte[4096]; int bytesRead = -1; while ((bytesRead = gzipInputStream.read(buffer)) != -1) { byteArrayOutputStream.write(buffer, 0, bytesRead); byteCount += bytesRead; } byteArrayOutputStream.flush(); gzipInputStream.close(); assertEquals("Content length does not match", body.length, byteCount); assertTrue("Invalid body", Arrays.equals(byteArrayOutputStream.toByteArray(), body)); } else { byte[] decompressedBody = FileCopyUtils.copyToByteArray(req.getInputStream()); assertTrue("Invalid body", Arrays.equals(decompressedBody, body)); } }
private byte[] getBuffer(File f) throws Exception { if (!f.exists()) return null; byte[] buffer = new byte[(int) f.length()]; DataInputStream dis = new DataInputStream(new FileInputStream(f)); dis.readFully(buffer); dis.close(); byte[] gzipInputBuffer = new byte[999999]; int bufferlength = 0; GZIPInputStream gzip = new GZIPInputStream(new ByteArrayInputStream(buffer)); do { if (bufferlength == gzipInputBuffer.length) { System.out.println("Error inflating data.\nGZIP buffer overflow."); break; } int readByte = gzip.read(gzipInputBuffer, bufferlength, gzipInputBuffer.length - bufferlength); if (readByte == -1) break; bufferlength += readByte; } while (true); byte[] inflated = new byte[bufferlength]; System.arraycopy(gzipInputBuffer, 0, inflated, 0, bufferlength); buffer = inflated; if (buffer.length < 10) return null; return buffer; }
public OnDemandData getNextNode() { OnDemandData onDemandData; synchronized (aClass19_1358) { onDemandData = (OnDemandData) aClass19_1358.popHead(); } if (onDemandData == null) return null; synchronized (nodeSubList) { onDemandData.unlist(); } if (onDemandData.buffer == null) return onDemandData; int i = 0; try { GZIPInputStream gzipinputstream = new GZIPInputStream(new ByteArrayInputStream(onDemandData.buffer)); do { if (i == gzipInputBuffer.length) throw new RuntimeException("buffer overflow!"); int k = gzipinputstream.read(gzipInputBuffer, i, gzipInputBuffer.length - i); if (k == -1) break; i += k; } while (true); } catch (IOException _ex) { throw new RuntimeException("error unzipping"); } onDemandData.buffer = new byte[i]; System.arraycopy(gzipInputBuffer, 0, onDemandData.buffer, 0, i); return onDemandData; }
/** * Decompress a compressed event string. * * @param str Compressed string * @return Decompressed string */ private String decompress(String str) { ByteArrayInputStream byteInputStream = null; GZIPInputStream gzipInputStream = null; BufferedReader br = null; try { byteInputStream = new ByteArrayInputStream(DatatypeConverter.parseBase64Binary(str)); gzipInputStream = new GZIPInputStream(byteInputStream); br = new BufferedReader(new InputStreamReader(gzipInputStream, CharEncoding.UTF_8)); StringBuilder jsonStringBuilder = new StringBuilder(); String line; while ((line = br.readLine()) != null) { jsonStringBuilder.append(line); } return jsonStringBuilder.toString(); } catch (IOException e) { throw new RuntimeException( "Error occured while decompressing events string: " + e.getMessage(), e); } finally { try { if (byteInputStream != null) { byteInputStream.close(); } if (gzipInputStream != null) { gzipInputStream.close(); } if (br != null) { br.close(); } } catch (IOException e) { log.error("Error occured while closing streams: " + e.getMessage(), e); } } }
private byte[] ungzip5(final byte[] gzip) throws IOException { int size = 0; int counter = 0; GZIPInputStream gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(gzip)); int bytesRead = 0; byte[] buffer = new byte[32768]; byte[] tempBuffer = new byte[4096]; counter = 0; while (bytesRead != -1) { bytesRead = gzipInputStream.read(tempBuffer); if (bytesRead != -1) { if (buffer.length < counter + bytesRead) { byte[] newBuffer = new byte[buffer.length + 32768]; System.arraycopy(buffer, 0, newBuffer, 0, counter); buffer = newBuffer; } System.arraycopy(tempBuffer, 0, buffer, counter, bytesRead); counter += bytesRead; } } gzipInputStream.close(); size = counter; byte[] unzipped = new byte[size]; System.arraycopy(buffer, 0, unzipped, 0, counter); return unzipped; }
public ByteArrayHub(long key, byte unitSize, int maxUnits, File basePath) { this.unitSize = unitSize; this.maxUnits = maxUnits; this.key = key; unitOffset = maxUnits * unitSize; path = new File(basePath, Long.toHexString(key).toUpperCase() + ".acache"); data = new byte[unitOffset * ByteArrayCache.CACHE_MAX_SIZE + ByteArrayCache.HEADER_SIZE]; returnCache = new byte[unitSize * maxUnits]; if (path.exists()) { GZIPInputStream inStream; try { inStream = new GZIPInputStream(new FileInputStream(path)); byte[] readBuffer = new byte[1024]; int len; int offset = 0; while ((len = inStream.read(readBuffer)) != -1) { System.arraycopy(readBuffer, 0, data, offset, len); offset += len; } // Log.i("@@@@@ " + inStream.read(data)); inStream.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
public static String getStringFromCompressedFile(File file) throws IOException { GZIPInputStream in = new GZIPInputStream(new FileInputStream(file)); try { return getStringFromInputStream(in); } finally { in.close(); } }
String getContent(HttpMethod httpMethod) { StringBuilder contentBuilder = new StringBuilder(); if (isZipContent(httpMethod)) { InputStream is = null; GZIPInputStream gzin = null; InputStreamReader isr = null; BufferedReader br = null; try { is = httpMethod.getResponseBodyAsStream(); gzin = new GZIPInputStream(is); isr = new InputStreamReader( gzin, ((HttpMethodBase) httpMethod).getResponseCharSet()); // ���ö�ȡ���ı����ʽ���Զ������ br = new BufferedReader(isr); char[] buffer = new char[4096]; int readlen = -1; while ((readlen = br.read(buffer, 0, 4096)) != -1) { contentBuilder.append(buffer, 0, readlen); } } catch (Exception e) { log.error("Unzip fail", e); } finally { try { br.close(); } catch (Exception e1) { // ignore } try { isr.close(); } catch (Exception e1) { // ignore } try { gzin.close(); } catch (Exception e1) { // ignore } try { is.close(); } catch (Exception e1) { // ignore } } } else { String content = null; try { content = httpMethod.getResponseBodyAsString(); } catch (Exception e) { log.error("Fetch config error:", e); } if (null == content) { return null; } contentBuilder.append(content); } return contentBuilder.toString(); }
/** * Decompress GZIP (RFC 1952) compressed data * * @param compressedData * @return A string containing the decompressed data * @throws IOException */ public static String decompressGzip(byte[] compressedData) throws IOException { byte[] buffer = new byte[compressedData.length]; ByteArrayOutputStream out = new ByteArrayOutputStream(); GZIPInputStream in = new GZIPInputStream(new ByteArrayInputStream(compressedData)); for (int bytesRead = 0; bytesRead != -1; bytesRead = in.read(buffer)) { out.write(buffer, 0, bytesRead); } return new String(out.toByteArray(), "UTF-8"); }
/** Uncompress a GZIP file. */ private static File getGzFile(FileObject in, File out, boolean isTar) throws IOException { // Stream buffer final int BUFF_SIZE = 8192; final byte[] buffer = new byte[BUFF_SIZE]; GZIPInputStream inputStream = null; FileOutputStream outStream = null; try { inputStream = new GZIPInputStream(new FileInputStream(in.getPath())); outStream = new FileOutputStream(out); if (isTar) { // Read Tar header int remainingBytes = readTarHeader(inputStream); // Read content ByteBuffer bb = ByteBuffer.allocateDirect(4 * BUFF_SIZE); byte[] tmpCache = new byte[BUFF_SIZE]; int nRead, nGet; while ((nRead = inputStream.read(tmpCache)) != -1) { if (nRead == 0) { continue; } bb.put(tmpCache); bb.position(0); bb.limit(nRead); while (bb.hasRemaining() && remainingBytes > 0) { nGet = Math.min(bb.remaining(), BUFF_SIZE); nGet = Math.min(nGet, remainingBytes); bb.get(buffer, 0, nGet); outStream.write(buffer, 0, nGet); remainingBytes -= nGet; } bb.clear(); } } else { int len; while ((len = inputStream.read(buffer)) > 0) { outStream.write(buffer, 0, len); } } } catch (IOException ex) { Exceptions.printStackTrace(ex); } finally { if (inputStream != null) { inputStream.close(); } if (outStream != null) { outStream.close(); } } return out; }
public static byte[] gzDecompress(byte[] b) throws IOException { GZIPInputStream gzi = new GZIPInputStream(new ByteArrayInputStream(b)); ByteArrayOutputStream out = new ByteArrayOutputStream(); byte[] buf = new byte[1024]; int len; while ((len = gzi.read(buf)) > 0) { out.write(buf, 0, len); } out.close(); return out.toByteArray(); }
/** * 数据解压缩 * * @param is * @param os * @throws Exception */ public static void decompress(InputStream is, OutputStream os) throws Exception { GZIPInputStream gis = new GZIPInputStream(is); int count; byte data[] = new byte[BUFFER]; while ((count = gis.read(data, 0, BUFFER)) != -1) { os.write(data, 0, count); } gis.close(); }