Shulou(Shulou.com)05/31 Report--

This article introduces the relevant knowledge of "what is the source code of java.nio.ByteBuffer". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

Version: JDK7

Package java.nio

Public abstract class ByteBuffer extends Buffer implements Comparable {

/ / These fields are declared here rather than in Heap-X-Buffer in order to// reduce the number of virtual method invocations needed to access these// values, which is especially costly when coding small buffers.//final byte [] hb; / / Non-null only for heap buffersfinal int offset;boolean isReadOnly; / / Valid only for heap buffersByteBuffer (int mark, int pos, int lim, int cap, byte [] hb, int offset) {super (mark, pos, lim, cap) This.hb = hb; this.offset = offset;} ByteBuffer (int mark, int pos, int lim, int cap) {/ / package-private this (mark, pos, lim, cap, null, 0);} / / create a ByteBuffer object public static ByteBuffer allocateDirect (int capacity) {return new DirectByteBuffer (capacity) with capacity capacity;} / / create a ByteBuffer object public static ByteBuffer allocate (int capacity) {if (capacity) with capacity capacity

< 0) throw new IllegalArgumentException(); return new HeapByteBuffer(capacity, capacity);}public static ByteBuffer wrap(byte[] array, int offset, int length) { try { return new HeapByteBuffer(array, offset, length); } catch (IllegalArgumentException x) { throw new IndexOutOfBoundsException(); }}public static ByteBuffer wrap(byte[] array) { return wrap(array, 0, array.length);}public abstract ByteBuffer slice();public abstract ByteBuffer duplicate();public abstract ByteBuffer asReadOnlyBuffer();/** * Reads the byte at this buffer's position, and then increments the position. */// 读取单个字节，并将position自增1public abstract byte get();/** * Writes the given byte into this buffer at the current position, and then increments the position. */// 将给定的单个字节写入缓冲区的当前位置，并将position自增1public abstract ByteBuffer put(byte b);// 读取指定位置的字节，注意：不会改变positionpublic abstract byte get(int index);// 将给定的单个字节写入缓冲区的index位置，注意：不会改变positionpublic abstract ByteBuffer put(int index, byte b);// -- Bulk get operations --/** * This method transfers bytes from this buffer into the given destination array. */// (从Buffer中)读取多个字节(从索引offset开始,读取length长度的数据)到dst中，如果Buffer剩余的空间小于length，则抛异常public ByteBuffer get(byte[] dst, int offset, int length) { checkBounds(offset, length, dst.length); if (length >

Remaining () throw new BufferUnderflowException (); int end = offset + length; for (int I = offset; I

< end; i++) dst[i] = get(); return this;}/** * This method transfers bytes from this buffer into the given destination array. */// 批量读取dst.length个字节到dst中，如果Buffer剩余的空间小于dst的length，则抛异常public ByteBuffer get(byte[] dst) { return get(dst, 0, dst.length);}// -- Bulk put operations --/** * 将src中的数据写入Buffer的当前位置 */public ByteBuffer put(ByteBuffer src) { if (src == this) throw new IllegalArgumentException(); int n = src.remaining(); if (n >

Remaining () throw new BufferOverflowException (); for (int I = 0; I

< n; i++) put(src.get()); return this;}public ByteBuffer put(byte[] src, int offset, int length) { checkBounds(offset, length, src.length); if (length >

Remaining () throw new BufferOverflowException (); int end = offset + length; for (int I = offset; I

< end; i++) this.put(src[i]); return this;}public final ByteBuffer put(byte[] src) { return put(src, 0, src.length);}// -- Other stuff --/** * Tells whether or not this buffer is backed by an accessible byte array. * * If this method returns true then the {[@link](https://my.oschina.net/u/393) #array() array} * and {[@link](https://my.oschina.net/u/393) #arrayOffset() arrayOffset} methods may safely be invoked. * * * [@return](https://my.oschina.net/u/556800) true if, and only if, this buffer * is backed by an array and is not read-only */public final boolean hasArray() { return (hb != null) && !isReadOnly;}/** * Returns the byte array that backs this * buffer (optional operation). * * Modifications to this buffer's content will cause the returned * array's content to be modified, and vice versa. * * Invoke the {[@link](https://my.oschina.net/u/393) #hasArray hasArray} method before invoking this * method in order to ensure that this buffer has an accessible backing * array. * * [@return](https://my.oschina.net/u/556800) The array that backs this buffer * * @throws ReadOnlyBufferException * If this buffer is backed by an array but is read-only * * @throws UnsupportedOperationException * If this buffer is not backed by an accessible array */public final byte[] array() { if (hb == null) throw new UnsupportedOperationException(); if (isReadOnly) throw new ReadOnlyBufferException(); return hb;}/** * Returns the offset within this buffer's backing array of the first * element of the buffer (optional operation). * * If this buffer is backed by an array then buffer position p * corresponds to array index p + arrayOffset(). * * Invoke the {@link #hasArray hasArray} method before invoking this * method in order to ensure that this buffer has an accessible backing * array. * * @return The offset within this buffer's array * of the first element of the buffer * * @throws ReadOnlyBufferException * If this buffer is backed by an array but is read-only * * @throws UnsupportedOperationException * If this buffer is not backed by an accessible array */public final int arrayOffset() { if (hb == null) throw new UnsupportedOperationException(); if (isReadOnly) throw new ReadOnlyBufferException(); return offset;}/** * Compacts this buffer. 压缩并整理Buffer。 * * The bytes between the buffer's current position and its limit, if any, are copied to the beginning of the buffer. * That is, the byte at index p=position() is copied to index zero, * the byte at index p+1 is copied to index one, * and so forth until the byte at index limit()-1 is copied to index n=limit()-1-p * The buffer's position is then set to n+1 and its limit is set to its capacity. The mark, if defined, is discarded. * * 即：将所有未读的数据拷贝到Buffer的起始处，然后将position设到最后一个未读元素的后面 * limit设置为capacity，此时，如果向Buffer中写数据，则不会覆盖之前未读的数据！ * 与clear()方法的比较： * 如果Buffer中存在未读的数据，调用clear()方法后，这些未读的数据将会被"遗忘"，因为在clear之后，position的值为0，故无法确定未读数据的位置。 */public abstract ByteBuffer compact();/** * Tells whether or not this byte buffer is direct. */public abstract boolean isDirect();public String toString() { StringBuffer sb = new StringBuffer(); sb.append(getClass().getName()); sb.append("[pos="); sb.append(position()); sb.append(" lim="); sb.append(limit()); sb.append(" cap="); sb.append(capacity()); sb.append("]"); return sb.toString();}/** * Returns the current hash code of this buffer. */public int hashCode() { int h = 1; int p = position(); for (int i = limit() - 1; i >

= p; iMel -) h = 31 * h + (int) get (I); return h;} / * * Tells whether or not this buffer is equal to another object. * * They have the same element type, * They have the same number of remaining elements, * and The two sequences of remaining elements, * considered independently of their starting positions, are pointwise equal. * * that is, if the elements in Buffer are of the same type and the remaining elements are exactly the same, then return true * Note: not all the data in Buffer is compared, only the remaining data in Buffer is compared. * / public boolean equals (Object ob) {if (this = = ob) return true; if (! (ob instanceof ByteBuffer)) return false; ByteBuffer that = (ByteBuffer) ob; if (this.remaining ()! = that.remaining ()) return false; int p = this.position (); for (int I = this.limit ()-1, j = that.limit ()-1; I > = p If (! equals (this.get (I), that.get (j)) return false; return true;} private static boolean equals (byte x, byte y) {return x = y;} / * Compares this buffer to another. * * compare the remaining elements of two Buffer * scenarios where one Buffer is "less than" the other Buffer: * the first unequal element is smaller than the corresponding element in the other Buffer * all elements are equal. But the number of elements of the first Buffer is less than that of the other Buffer * / public int compareTo (ByteBuffer that) {int n = this.position () + Math.min (this.remaining (), that.remaining ()) For (int I = this.position (), j = that.position (); I < n; iTunes, jacks +) {int cmp = compare (this.get (I), that.get (j)); if (cmp! = 0) return cmp;} return this.remaining ()-that.remaining ();} private static int compare (byte x, byte y) {return Byte.compare (x, y) } / /-- Other char stuff-/-- Other byte stuff: Access to binary data-- boolean bigEndian = true; / / package-private boolean nativeByteOrder = (Bits.byteOrder () = = ByteOrder.BIG_ENDIAN); / / package-private / * Retrieves this buffer's byte order. * *

The byte order is used when reading or writing multibyte values, and * when creating buffers that are views of this byte buffer. The order of * a newly-created byte buffer is always {@ link ByteOrder#BIG_ENDIAN * BIG_ENDIAN}.

* * @ return This buffer's byte order * / public final ByteOrder order () {return bigEndian? ByteOrder.BIG_ENDIAN: ByteOrder.LITTLE_ENDIAN;} / * * Modifies this buffer's byte order.

* * @ param bo * The new byte order, * either {@ link ByteOrder#BIG_ENDIAN BIG_ENDIAN} * or {@ link ByteOrder#LITTLE_ENDIAN LITTLE_ENDIAN} * * @ return This buffer * / public final ByteBuffer order (ByteOrder bo) {bigEndian = (bo = = ByteOrder.BIG_ENDIAN); nativeByteOrder = (bigEndian = = (Bits.byteOrder () = = ByteOrder.BIG_ENDIAN)); return this } / / Unchecked accessors, for use by ByteBufferAs-X-Buffer classes//abstract byte _ get (int I); / / package-privateabstract void _ put (int I, byte b); / / package-private/** * Relative get method for reading an int value. * *

Reads the next four bytes at this buffer's current position, * composing them into an int value according to the current byte order, * and then increments the position by four.

* * @ return The int value at the buffer's current position * * @ throws BufferUnderflowException * If there are fewer than four bytes * remaining in this buffer * / public abstract int getInt (); / * * Relative put method for writing an int * value (optional operation). * *

Writes four bytes containing the given int value, in the * current byte order, into this buffer at the current position, and then * increments the position by four.

* * @ param value * The int value to be written * * @ return This buffer * * @ throws BufferOverflowException * If there are fewer than four bytes * remaining in this buffer * * @ throws ReadOnlyBufferException * If this buffer is read-only * / public abstract ByteBuffer putInt (int value); / * * Absolute get method for reading an int value. * *

Reads four bytes at the given index, composing them into a * int value according to the current byte order.

* * @ param index * The index from which the bytes will be read * * @ return The int value at the given index * * @ throws IndexOutOfBoundsException * If index is negative * or not smaller than the buffer's limit, * minus three * / public abstract int getInt (int index); / * * Absolute put method for writing an int * value (optional operation). * *

Writes four bytes containing the given int value, in the * current byte order, into this buffer at the given index.

* * @ param index * The index at which the bytes will be written * * @ param value * The int value to be written * * @ return This buffer * @ throws IndexOutOfBoundsException * If index is negative * or not smaller than the buffer's limit, * minus three * * @ throws ReadOnlyBufferException * If this buffer is read-only * / public abstract ByteBuffer putInt (int index, int value) / * Creates a view of this byte buffer as an int buffer. * *

The content of the new buffer will start at this buffer's current * position. Changes to this buffer's content will be visible in the new * buffer, and vice versa; the two buffers' position, limit, and mark * values will be independent. * *

The new buffer's position will be zero, its capacity and its limit * will be the number of bytes remaining in this buffer divided by * four, and its mark will be undefined. The new buffer will be direct * if, and only if, this buffer is direct, and it will be read-only if, and * only if, this buffer is read-only.

* * @ return A new int buffer * / public abstract IntBuffer asIntBuffer (); / /

}

This is the end of the content of "what is the java.nio.ByteBuffer source code?" Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.