Java BZip2CompressorInputStream.read方法代碼示例

import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream; //導入方法依賴的package包/類
@Override
public byte[] uncompress(byte[] data) throws IOException {
	ByteArrayOutputStream out = new ByteArrayOutputStream();
	ByteArrayInputStream in = new ByteArrayInputStream(data);

	try {
		@SuppressWarnings("resource")
		BZip2CompressorInputStream ungzip = new BZip2CompressorInputStream(in);
		byte[] buffer = new byte[2048];
		int n;
		while ((n = ungzip.read(buffer)) >= 0) {
			out.write(buffer, 0, n);
		}
	} catch (IOException e) {
		e.printStackTrace();
	}

	return out.toByteArray();
}
 

import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream; //導入方法依賴的package包/類
public String[] readRecordsDirectly(URL testFileUrl, boolean bzip)
    throws IOException {
  int MAX_DATA_SIZE = 1024 * 1024;
  byte[] data = new byte[MAX_DATA_SIZE];
  FileInputStream fis = new FileInputStream(testFileUrl.getFile());
  int count;
  if (bzip) {
    BZip2CompressorInputStream bzIn = new BZip2CompressorInputStream(fis);
    count = bzIn.read(data);
    bzIn.close();
  } else {
    count = fis.read(data);
  }
  fis.close();
  assertTrue("Test file data too big for buffer", count < data.length);
  return new String(data, 0, count, "UTF-8").split("\n");
}
 

import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream; //導入方法依賴的package包/類
private byte[] extractBzip2ByteArray(byte[] data) {
	byte[] b = null;
	try {
		ByteArrayInputStream bis = new ByteArrayInputStream(data);
		BZip2CompressorInputStream bzip2 = new BZip2CompressorInputStream(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;

}
 

import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream; //導入方法依賴的package包/類
/**
 *
 * @param file
 * @return
 */
public static BufferedReader openBZip2File(final String file) {
  String s = "";
  try {
    final FileInputStream in = new FileInputStream(file);
    final ByteArrayOutputStream out = new ByteArrayOutputStream();
    final BZip2CompressorInputStream bzIn = new BZip2CompressorInputStream(in);
    final byte[] buffer = new byte[1028];
    int n = 0;
    while (-1 != (n = bzIn.read(buffer))) {
      out.write(buffer, 0, n);
    }
    out.close();
    bzIn.close();
    s = out.toString();
  } catch (final Exception e) {
    LOG.error("\n", e);
    return null;
  }
  return new BufferedReader(new StringReader(s));
}
 

import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream; //導入方法依賴的package包/類
@Override
protected byte[] doDecompress(byte[] compressed) throws IOException {

    @Cleanup ByteArrayOutputStream bos = new ByteArrayOutputStream();
    @Cleanup ByteArrayInputStream bis = new ByteArrayInputStream(compressed);
    @Cleanup BZip2CompressorInputStream bzip2 = new BZip2CompressorInputStream(bis);

    byte[] buff = new byte[BUFFER_SIZE];
    int n;
    while ((n = bzip2.read(buff, 0, BUFFER_SIZE)) > 0) {
        bos.write(buff, 0, n);
    }

    return bos.toByteArray();
}
 

import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream; //導入方法依賴的package包/類
/**
 * Reassembles the data of a split and/or compressed packet into a single
 * packet object
 *
 * @param splitPackets An array of packet data
 * @param isCompressed whether the data of this packet is compressed
 * @param uncompressedSize The size of the decompressed packet data
 * @param packetChecksum The CRC32 checksum of the decompressed
 *        packet data
 * @throws SteamCondenserException if decompressing the packet data fails
 * @throws PacketFormatException if the calculated CRC32 checksum does not
 *         match the expected value
 * @return SteamPacket The reassembled packet
 * @see SteamPacketFactory#getPacketFromData
 */
public static SteamPacket reassemblePacket(ArrayList<byte[]> splitPackets,
        boolean isCompressed, int uncompressedSize, int packetChecksum)
        throws SteamCondenserException {
    byte[] packetData, tmpData;
    packetData = new byte[0];

    for(byte[] splitPacket : splitPackets) {
        tmpData = packetData;
        packetData = new byte[tmpData.length + splitPacket.length];
        System.arraycopy(tmpData, 0, packetData, 0, tmpData.length);
        System.arraycopy(splitPacket, 0, packetData, tmpData.length,
                splitPacket.length);
    }

    if(isCompressed) {
        try {
            ByteArrayInputStream stream = new ByteArrayInputStream(packetData);
            stream.read();
            stream.read();
            BZip2CompressorInputStream bzip2 = new BZip2CompressorInputStream(stream);
            byte[] uncompressedPacketData = new byte[uncompressedSize];
            bzip2.read(uncompressedPacketData, 0, uncompressedSize);

            CRC32 crc32 = new CRC32();
            crc32.update(uncompressedPacketData);
            int crc32checksum = (int) crc32.getValue();

            if (crc32checksum != packetChecksum) {
                throw new PacketFormatException(
                        "CRC32 checksum mismatch of uncompressed packet data.");
            }
            packetData = uncompressedPacketData;
        } catch(IOException e) {
            throw new SteamCondenserException(e.getMessage(), e);
        }
    }

    tmpData = packetData;
    packetData = new byte[tmpData.length - 4];
    System.arraycopy(tmpData, 4, packetData, 0, tmpData.length - 4);

    return SteamPacketFactory.getPacketFromData(packetData);
}