Java BZip2CompressorInputStream类代码示例

import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream; //导入依赖的package包/类
private void setupSegmentsAndOutput(PatchExecutor executor)
    throws CompressorException, IOException {
  controlBlockLen = readOffset();
  diffBlockLen = readOffset();
  int newFileSize = readOffset();

  extraBlockLen =
      patchInput.array().length - (BSDIFF_HEADER_LENGTH + controlBlockLen + diffBlockLen);

  executor.createOutput(newFileSize);
  controlStream = new BZip2CompressorInputStream(
      new ByteArrayInputStream(patchInput.array(), BSDIFF_HEADER_LENGTH, controlBlockLen));
  diffStream = new BZip2CompressorInputStream(
      new ByteArrayInputStream(patchInput.array(), BSDIFF_HEADER_LENGTH + controlBlockLen,
          diffBlockLen));
  extraStream = new BZip2CompressorInputStream(
      new ByteArrayInputStream(patchInput.array(),
          BSDIFF_HEADER_LENGTH + controlBlockLen + diffBlockLen,
          extraBlockLen));
}
 

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包/类
@Override
public void startRevisionProcessing() {
	logger.debug("Starting...");
	try {
		BufferedReader csvReader;

		csvReader = new BufferedReader(
		new InputStreamReader(
		new BZip2CompressorInputStream(
		new BufferedInputStream(
		new FileInputStream(geolocationFeatureFile))), "UTF-8"));

		csvParser = new CSVParser(csvReader,
				CSVFormat.RFC4180.withHeader());
		iterator = csvParser.iterator();
	
		processor.startRevisionProcessing();
	
	} catch (IOException e) {
		logger.error("", e);
	}
}
 

import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream; //导入依赖的package包/类
@Override
public void startRevisionProcessing() {
	logger.info("Starting...");
	
	InputStream compressedLabelsInputStream;
	
	try {
		compressedLabelsInputStream = new FileInputStream(labelFile);

		InputStream uncompressedLabelsInputStream =
				new BZip2CompressorInputStream(
				new BufferedInputStream(compressedLabelsInputStream));
		
		labelReader = new CorpusLabelReader(uncompressedLabelsInputStream);
	
	} catch (IOException e) {
		logger.error("", e);
	}		
	
	processor.startRevisionProcessing();
	
	labelReader.startReading();
}
 

import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream; //导入依赖的package包/类
private static InputStream getUncompressedStream(
		final InputStream inputStream) throws IOException {
	// the decompression is a major bottleneck, make sure that it does not
	// have to wait for the buffer to empty
	final PipedOutputStream pipedOutputStream = new PipedOutputStream();
	final PipedInputStream pipedInputStream = new PipedInputStream(pipedOutputStream, BUFFER_SIZE);
	
	new Thread("Dump File Decompressor") {
		@Override
		public void run() {
			try {
				InputStream compressorInputStream =
						new BZip2CompressorInputStream(inputStream);
				
				IOUtils.copy(compressorInputStream, pipedOutputStream);
				
				compressorInputStream.close();
				pipedOutputStream.close();
			} catch (IOException e) {
				logger.error("", e);
			}
		}
	}.start();
	
	return pipedInputStream;
}
 

import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream; //导入依赖的package包/类
public static byte[] decompress(byte[] bytes, int len) throws IOException
{
	byte[] data = new byte[len + BZIP_HEADER.length];

	// add header
	System.arraycopy(BZIP_HEADER, 0, data, 0, BZIP_HEADER.length);
	System.arraycopy(bytes, 0, data, BZIP_HEADER.length, len);

	ByteArrayOutputStream os = new ByteArrayOutputStream();

	try (InputStream is = new BZip2CompressorInputStream(new ByteArrayInputStream(data)))
	{
		IOUtils.copy(is, os);
	}

	return os.toByteArray();
}
 

import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream; //导入依赖的package包/类
@Inject
public Stagger(@LanguageCode String lang, @Model(MODEL_ID) Resource path) throws LangforiaException {
	this(lang);

	Logger logger = LoggerFactory.getLogger(Stagger.class);

	logger.info("Loading stagger model " + path.name());
	try
	{
		ObjectInputStream modelReader = new ObjectInputStream(new BufferedInputStream(new BZip2CompressorInputStream(path.binaryRead()), 1024*1024));
		tagger = (Tagger)modelReader.readObject();
		modelReader.close();
	}
	catch(Exception ex)
	{
		throw new LangforiaException("Failed to load stagger model.", ex);
	}

	posTagSet = tagger.getTaggedData().getPosTagSet();
	neTagSet = tagger.getTaggedData().getNETagSet();
	neTagTypeSet = tagger.getTaggedData().getNETypeTagSet();
	logger.info("Stagger model loaded.");
}
 

import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream; //导入依赖的package包/类
/**
 * Decodes a byte array as an InputStream. The byte array may be compressed using some
 * codec. Reads from the returned stream will result in decompressed bytes.
 *
 * <p>This supports the same codecs as Avro's {@link CodecFactory}, namely those defined in
 * {@link DataFileConstants}.
 *
 * <ul>
 * <li>"snappy" : Google's Snappy compression
 * <li>"deflate" : deflate compression
 * <li>"bzip2" : Bzip2 compression
 * <li>"xz" : xz compression
 * <li>"null" (the string, not the value): Uncompressed data
 * </ul>
 */
private static InputStream decodeAsInputStream(byte[] data, String codec) throws IOException {
  ByteArrayInputStream byteStream = new ByteArrayInputStream(data);
  switch (codec) {
    case DataFileConstants.SNAPPY_CODEC:
      return new SnappyCompressorInputStream(byteStream, 1 << 16 /* Avro uses 64KB blocks */);
    case DataFileConstants.DEFLATE_CODEC:
      // nowrap == true: Do not expect ZLIB header or checksum, as Avro does not write them.
      Inflater inflater = new Inflater(true);
      return new InflaterInputStream(byteStream, inflater);
    case DataFileConstants.XZ_CODEC:
      return new XZCompressorInputStream(byteStream);
    case DataFileConstants.BZIP2_CODEC:
      return new BZip2CompressorInputStream(byteStream);
    case DataFileConstants.NULL_CODEC:
      return byteStream;
    default:
      throw new IllegalArgumentException("Unsupported codec: " + codec);
  }
}
 

import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream; //导入依赖的package包/类
public static BufferedReader getBufferedReader (File file) throws FileNotFoundException, IOException
{
	
	if (file.getName().matches("^.+\\.gz$")||file.getName().matches("^.+\\.gzip$"))
	{
		GZIPInputStream gzip = new GZIPInputStream(new FileInputStream(file));
		return new BufferedReader(new InputStreamReader(gzip));
	}
	else if(file.getName().matches("^.+\\.bz2$")||file.getName().matches("^.+\\.bzip2$"))
	{
		BZip2CompressorInputStream bzIn = new BZip2CompressorInputStream(new FileInputStream(file));
		return new BufferedReader(new InputStreamReader(bzIn));
	}
	else
	{
		return new BufferedReader(new FileReader(file));
	}
	
}
 

import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream; //导入依赖的package包/类
private static void downloadOpenH264(File target, String libraryName) throws UnsatisfiedLinkError
{
   try
   {
      URL url = getVersionURL(libraryName);
      System.out.println("Downloading " + url + " to " + target);
      InputStream remote = url.openStream();
      BZip2CompressorInputStream decompressor = new BZip2CompressorInputStream(remote);
      NativeLibraryLoader.writeStreamToFile(decompressor, target);
      remote.close();

   }
   catch (IOException e)
   {
      throw new UnsatisfiedLinkError("Cannot download OpenH264 binary " + libraryName + " to " + target + ". Are you connected to the internet?");
   }
}
 

import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream; //导入依赖的package包/类
/**
 * The dump parser can deal with gzip, bzip or uncompressed files. This file
 * select the right reader.
 */
public BufferedReader getDumpReader(String file)
		throws UnsupportedEncodingException, FileNotFoundException {
	// attempt to use gzip first
	BufferedReader br = null;
	try {
		br = new BufferedReader(new InputStreamReader(new GZIPInputStream(
				new FileInputStream(new File(file))), "UTF-8"), 16 * 1024);
	} catch (IOException e) {
		System.out.println(file
				+ " is not gzipped, trying bzip input stream..");
		try {
			FileInputStream fin = new FileInputStream(file);
			BufferedInputStream in = new BufferedInputStream(fin);
			BZip2CompressorInputStream bzIn = new BZip2CompressorInputStream(
					in);
			br = new BufferedReader(new InputStreamReader(bzIn));
		} catch (IOException f) {
			System.out.println(file
					+ " is not bzip commpressed, trying decompressed file");
			br = new BufferedReader(new InputStreamReader(
					new FileInputStream(new File(file)), "UTF8"), 16 * 1024);
		}
	}
	return br;
}
 

import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream; //导入依赖的package包/类
/**
 * open a compressed InputStream
 * @param in the InputStream to decompress
 * @return the InputStream to read from
 * @throws IOException if an I/O error occurs
 */
private InputStream openCompressedStream(InputStream in) throws IOException {
  if(mCurrentTask.compression==null)
    return in;
  switch(mCurrentTask.compression) {
    default:
    case none:
      return in;
    case gzip:
      return new GzipCompressorInputStream(in);
    case bzip:
      return new BZip2CompressorInputStream(in);
    case xz:
      return new XZCompressorInputStream(in);
  }
}
 

import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream; //导入依赖的package包/类
/**
 * 
 * @return a BufferedReader created from wikiDumpFilename
 * @throws UnsupportedEncodingException
 * 
 */
public static BufferedReader getBufferedReader(String wikiDumpFilename) throws UnsupportedEncodingException,
		FileNotFoundException, IOException {
	BufferedReader br = null;

	if (wikiDumpFilename.endsWith(".gz")) {

		br = new BufferedReader(new InputStreamReader(new GZIPInputStream(new FileInputStream(wikiDumpFilename)), "UTF-8"));

	} else if (wikiDumpFilename.endsWith(".bz2")) {
		FileInputStream fis = new FileInputStream(wikiDumpFilename);
		br = new BufferedReader(new InputStreamReader(new BZip2CompressorInputStream(fis), "UTF-8"));
	} else {
		br = new BufferedReader(new InputStreamReader(new FileInputStream(wikiDumpFilename), "UTF-8"));
	}

	return br;
}
 

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;

}