Java Code Examples for java.nio.ByteBuffer

Following code examples demonstrate how to use java.nio.ByteBufferfrom android. These examples are extracted from various highly rated open source projects. You can directly use these code snippets or view their entire linked source code. These snippets are extracted to provide contextual information about how to use this class in the real world. These samples also let you understand some good practices on how to use java.nio.ByteBufferand various code implementation of this class.

    }

    private static java.nio.ByteBuffer readFileToBuffer(java.io.File file) throws IOException
    {
        FileInputStream is = new FileInputStream(file);
        try
        {
            FileChannel fc = is.getChannel();
            java.nio.ByteBuffer buffer = java.nio.ByteBuffer.allocate((int) fc.size());
            for (int count = 0; count >= 0 && buffer.hasRemaining();)
            {
                count = fc.read(buffer);
            }
            buffer.flip();
            return buffer;
        }
        finally
        {
            is.close();
        }
    } 


	public DataHeader readDataHeaderBlock(InputStream is) throws IOException {
		DataHeader hdr = new DataHeader();

		int ok = is.read(b4);
		hdr.siteId = new String(b4, StandardCharsets.UTF_8);

		ok = is.read(b4);
		hdr.msSinceMidnight = java.nio.ByteBuffer.wrap(b4).getInt();

		ok = is.read(b2);
		hdr.daysSince1970 = java.nio.ByteBuffer.wrap(b2).getShort();

		ok = is.read(b2);
		hdr.azimuthNum = java.nio.ByteBuffer.wrap(b2).getShort();

		ok = is.read(b4);
		hdr.azimuthAngle = java.nio.ByteBuffer.wrap(b4).getFloat();

		hdr.compression = is.read();

		ok = is.read(b2);
		hdr.radialLength = java.nio.ByteBuffer.wrap(b2).getShort();

		hdr.radialStatus = is.read();
		hdr.elevationNum = is.read();
		hdr.cutStatusNum = is.read();

		ok = is.read(b4);
		hdr.elevationAngle = java.nio.ByteBuffer.wrap(b4).getFloat();

		hdr.radialSpotBlankingStatus = is.read();
		hdr.azimuthIndexingMode = is.read();

		ok = is.read(b2);
		hdr.dataBlockCount = java.nio.ByteBuffer.wrap(b2).getShort();

		ok = is.read(b4);
		hdr.volumeBlockPointer = java.nio.ByteBuffer.wrap(b4).getInt();

		ok = is.read(b4);
		hdr.elevationBlockPointer = java.nio.ByteBuffer.wrap(b4).getInt();

		ok = is.read(b4);
		hdr.radialBlockPointer = java.nio.ByteBuffer.wrap(b4).getInt();

		ok = is.read(b4);
		hdr.reflectivityBlockPointer = java.nio.ByteBuffer.wrap(b4).getInt();

		ok = is.read(b4);
		hdr.velocityBlockPointer = java.nio.ByteBuffer.wrap(b4).getInt();

		ok = is.read(b4);
		hdr.spectrumWidthBlockPointer = java.nio.ByteBuffer.wrap(b4).getInt();

		ok = is.read(b4);
		hdr.zdrBlockPointer = java.nio.ByteBuffer.wrap(b4).getInt();

		ok = is.read(b4);
		hdr.phiBlockPointer = java.nio.ByteBuffer.wrap(b4).getInt();

		ok = is.read(b4);
		hdr.rhoBlockPointer = java.nio.ByteBuffer.wrap(b4).getInt();

		return hdr;
	} 

	public void readMetadataRecord(InputStream is) throws IOException { 
		int ok = is.read(b4);
		int recSize = Math.abs(java.nio.ByteBuffer.wrap(b4).getInt());
		byte[] bfull = new byte[recSize];
		ok = is.read(bfull);
		try (BZip2CompressorInputStream bzis = new BZip2CompressorInputStream(new ByteArrayInputStream(bfull));) {
			int cnt = 0;
			for(int i=0; i<134; i++){
				byte [] bb = new byte[2432];
				ok = bzis.read(bb);
			}
			System.err.println(cnt + " compressed records read");
			countBytes(bzis);
		} catch (IOException e) {
			e.printStackTrace();
		}
	} 

	public MessageHeader readMessageHeader(InputStream is) throws IOException {
		MessageHeader hdr = new MessageHeader();

		byte [] b12 = new  byte[12];
		if(ok == -1)  return null;

		ok = is.read(b2);
		hdr.messageSize = java.nio.ByteBuffer.wrap(b2).getShort();

		hdr.rdaByte = is.read();  
		hdr.messageType = is.read();

		hdr.sequenceNum = java.nio.ByteBuffer.wrap(b2).getShort();

		ok = is.read(b2);
		hdr.daysSince1970 = java.nio.ByteBuffer.wrap(b2).getShort();

		ok = is.read(b4);
		hdr.msSinceMidnight = java.nio.ByteBuffer.wrap(b4).getInt();

		ok = is.read(b2);
		hdr.numSegments = java.nio.ByteBuffer.wrap(b2).getShort();

		ok = is.read(b2);
		hdr.segmentNum = java.nio.ByteBuffer.wrap(b2).getShort();

		return hdr;
	} 

	public VolumeDataBlock readVolumeDataBlock(InputStream is) throws IOException {
		VolumeDataBlock block = new VolumeDataBlock();

		int ok = is.read(b4);
		block.dataName = new String(b4, StandardCharsets.UTF_8);

		ok = is.read(b2);
		block.blockSize = java.nio.ByteBuffer.wrap(b2).getShort();

		block.majorVersionNum = is.read();
		block.minorVersionNum = is.read();

		ok = is.read(b4);
		block.latitude = java.nio.ByteBuffer.wrap(b4).getFloat();

		ok = is.read(b4);
		block.longitude = java.nio.ByteBuffer.wrap(b4).getFloat();

		ok = is.read(b2);
		block.siteHeightAboveSeaLevelMeters = java.nio.ByteBuffer.wrap(b2).getShort();

		ok = is.read(b2);
		block.feedhornHeightAboveGroundMeters = java.nio.ByteBuffer.wrap(b2).getShort();

		for(int i=0; i<5; i++)
			ok = is.read(b4);

		ok = is.read(b2);
		block.volumeCoveragePattern = java.nio.ByteBuffer.wrap(b2).getShort();

		ok = is.read(b2);
		block.processingStatus = java.nio.ByteBuffer.wrap(b2).getShort();

		return block;
	} 

	public MomentDataBlock readMomentDataBlock(InputStream is) throws IOException {
		MomentDataBlock block = new MomentDataBlock();

		block.blockType = (char)is.read();

		byte [] b3 = new byte[3];
		int ok = is.read(b3);
		block.blockName = new String(b3, StandardCharsets.UTF_8);


		ok = is.read(b2);
		block.numGates = java.nio.ByteBuffer.wrap(b2).getShort();

		ok = is.read(b2);
		block.rangeToCenterOfFirstGate = java.nio.ByteBuffer.wrap(b2).getShort();

		ok = is.read(b2);
		block.rangeSampleInterval = java.nio.ByteBuffer.wrap(b2).getShort();

		ok = is.read(b2);
		block.rangeFoldingThreshold = java.nio.ByteBuffer.wrap(b2).getShort();

		ok = is.read(b2);
		block.snrThreshold = java.nio.ByteBuffer.wrap(b2).getShort();

		block.controlFlags = is.read();
		block.gateSizeBits = is.read();
		assert block.gateSizeBits == 8 || block.gateSizeBits == 16;

		ok = is.read(b4);
		block.scale = java.nio.ByteBuffer.wrap(b4).getFloat();

		ok = is.read(b4);
		block.offset = java.nio.ByteBuffer.wrap(b4).getFloat();

		int gateSizeBytes = block.gateSizeBits / 8;
		block.bdata = new byte[block.numGates * gateSizeBytes];
		ok = is.read(block.bdata);

		return block;
	} 

	public List<LdmRadial> readMessage31(InputStream is) throws IOException {
		int ok = is.read(b4);
		int msgSize = java.nio.ByteBuffer.wrap(b4).getInt();
		msgSize = Math.abs(msgSize);

		byte [] bfull = new byte[msgSize];
		ok = is.read(bfull);

		List<LdmRadial> ldmRadials = new ArrayList<>();

		ByteArrayInputStream bas = new ByteArrayInputStream(bfull);
		int radCnt = 1;
		try (BZip2CompressorInputStream bzis = new BZip2CompressorInputStream(bas) ) {
			while(true) {

				MessageHeader msgHdr = readMessageHeader(bzis);
				if(msgHdr == null)  break;
				switch(msgHdr.messageType) {
				case 2:
					readMessage2(bzis, msgHdr.messageSize);
					break;
				case 31:
					LdmRadial ldmRadial = new LdmRadial();
					ldmRadial.dataHeader = readDataHeaderBlock(bzis);
					ldmRadial.volumeDataBlock = readVolumeDataBlock(bzis);
					readElevationDataBlock(bzis);
					readRadialDataBlock(bzis);
					for(int i=0; i<ldmRadial.dataHeader.dataBlockCount - 3; i++) {
						MomentDataBlock momentBlock = readMomentDataBlock(bzis);
						ldmRadial.momentData.put(momentBlock.blockName, momentBlock);
					}
					ldmRadials.add(ldmRadial);
					radCnt++;

					break;
				default:
					throw new IOException("Unknown MessageType = " + msgHdr.messageType);
				}
			}
		}

		return ldmRadials;
	} 

	public VolumeHeader readVolumeHeader(InputStream is) throws IOException {
		VolumeHeader hdr = new VolumeHeader();
		byte [] fn = new byte[12];
		int ok = is.read(fn);
		hdr.archive2filename = new String(fn, StandardCharsets.UTF_8);
		ok = is.read(b4);
		hdr.daysSince1970 = java.nio.ByteBuffer.wrap(b4).getInt();
		ok = is.read(b4);
		hdr.msSinceMidnight = java.nio.ByteBuffer.wrap(b4).getInt();
		ok = is.read(b4);
		hdr.siteId = new String(b4, StandardCharsets.UTF_8);
		return hdr;
	} 

Advertisement
Javadoc
A byte buffer.

This class defines six categories of operations upon byte buffers:


Absolute and relative #get() get and #put(byte) put methods that read and write single bytes;

Relative #get(byte[]) bulk get methods that transfer contiguous sequences of bytes from this buffer into an array;

Relative #put(byte[]) bulk put methods that transfer contiguous sequences of bytes from a byte array or some other byte buffer into this buffer;

Absolute and relative #getChar() get and #putChar(char) put methods that read and write values of other primitive types, translating them to and from sequences of bytes in a particular byte order;

Methods for creating view buffers, which allow a byte buffer to be viewed as a buffer containing values of some other primitive type; and

Methods for #compact compacting, #duplicate duplicating, and #slice slicing a byte buffer.

Byte buffers can be created either by #allocate allocation, which allocates space for the buffer's content, or by #wrap(byte[]) wrapping an existing byte array into a buffer. Direct vs. non-direct buffers

A byte buffer is either direct or non-direct. Given a direct byte buffer, the Java virtual machine will make a best effort to perform native I/O operations directly upon it. That is, it will attempt to avoid copying the buffer's content to (or from) an intermediate buffer before (or after) each invocation of one of the underlying operating system's native I/O operations.

A direct byte buffer may be created by invoking the #allocateDirect(int) allocateDirect factory method of this class. The buffers returned by this method typically have somewhat higher allocation and deallocation costs than non-direct buffers. The contents of direct buffers may reside outside of the normal garbage-collected heap, and so their impact upon the memory footprint of an application might not be obvious. It is therefore recommended that direct buffers be allocated primarily for large, long-lived buffers that are subject to the underlying system's native I/O operations. In general it is best to allocate direct buffers only when they yield a measureable gain in program performance.

A direct byte buffer may also be created by java.nio.channels.FileChannel#map mapping a region of a file directly into memory. An implementation of the Java platform may optionally support the creation of direct byte buffers from native code via JNI. If an instance of one of these kinds of buffers refers to an inaccessible region of memory then an attempt to access that region will not change the buffer's content and will cause an unspecified exception to be thrown either at the time of the access or at some later time.

Whether a byte buffer is direct or non-direct may be determined by invoking its #isDirect isDirect method. This method is provided so that explicit buffer management can be done in performance-critical code. Access to binary data

This class defines methods for reading and writing values of all other primitive types, except boolean. Primitive values are translated to (or from) sequences of bytes according to the buffer's current byte order, which may be retrieved and modified via the #order order methods. Specific byte orders are represented by instances of the ByteOrder class. The initial order of a byte buffer is always ByteOrder#BIG_ENDIAN BIG_ENDIAN.

For access to heterogeneous binary data, that is, sequences of values of different types, this class defines a family of absolute and relative get and put methods for each type. For 32-bit floating-point values, for example, this class defines: float #getFloat() float #getFloat(int) getFloat(int index) void #putFloat(float) putFloat(float f) void #putFloat(int,float) putFloat(int index, float f)

Corresponding methods are defined for the types char, short, int, long, and double. The index parameters of the absolute get and put methods are in terms of bytes rather than of the type being read or written.

For access to homogeneous binary data, that is, sequences of values of the same type, this class defines methods that can create views of a given byte buffer. A view buffer is simply another buffer whose content is backed by the byte buffer. Changes to the byte buffer's content will be visible in the view buffer, and vice versa; the two buffers' position, limit, and mark values are independent. The #asFloatBuffer() asFloatBuffer method, for example, creates an instance of the FloatBuffer class that is backed by the byte buffer upon which the method is invoked. Corresponding view-creation methods are defined for the types char, short, int, long, and double.

View buffers have three important advantages over the families of type-specific get and put methods described above:

A view buffer is indexed not in terms of bytes but rather in terms of the type-specific size of its values;

A view buffer provides relative bulk get and put methods that can transfer contiguous sequences of values between a buffer and an array or some other buffer of the same type; and

A view buffer is potentially much more efficient because it will be direct if, and only if, its backing byte buffer is direct.

The byte order of a view buffer is fixed to be that of its byte buffer at the time that the view is created. Invocation chaining

Methods in this class that do not otherwise have a value to return are specified to return the buffer upon which they are invoked. This allows method invocations to be chained. The sequence of statements bb.putInt(0xCAFEBABE); bb.putShort(3); bb.putShort(45); can, for example, be replaced by the single statement bb.putInt(0xCAFEBABE).putShort(3).putShort(45); @author Mark Reinhold @author JSR-51 Expert Group @since 1.4

Read More
Advertisement