Bytes (Aliyun Open Services SDK for Java 2.2.6 API)

java.lang.Object
- com.aliyun.openservices.ots.utils.Bytes

```
public class Bytes
extends Object
```

嵌套类概要

嵌套类
限定符和类型类和说明

static class Bytes.WritableUtils

嵌套类
限定符和类型	类和说明
`static class`	`Bytes.WritableUtils`

字段概要

字段
限定符和类型	字段和说明
`static int`	`ESTIMATED_HEAP_TAX` Estimate of size cost to pay beyond payload in jvm for instance of byte [].
`static int`	`SIZEOF_BOOLEAN` Size of boolean in bytes
`static int`	`SIZEOF_BYTE` Size of byte in bytes
`static int`	`SIZEOF_CHAR` Size of char in bytes
`static int`	`SIZEOF_DOUBLE` Size of double in bytes
`static int`	`SIZEOF_FLOAT` Size of float in bytes
`static int`	`SIZEOF_INT` Size of int in bytes
`static int`	`SIZEOF_LONG` Size of long in bytes
`static int`	`SIZEOF_SHORT` Size of short in bytes

构造器概要

构造器
构造器和说明

Bytes()

构造器
构造器和说明
`Bytes()`

方法概要

所有方法静态方法具体方法
限定符和类型	方法和说明
`static long`	`bytesToVint(byte[] buffer)`
`static int`	`compareByteArrayInLexOrder(byte[] buffer1, int offset1, int length1, byte[] buffer2, int offset2, int length2)`
`static int`	`compareTo(byte[] left, byte[] right)`
`static int`	`compareTo(byte[] buffer1, int offset1, int length1, byte[] buffer2, int offset2, int length2)` Lexicographically compare two arrays.
`static byte[]`	`copyBytes(byte[] bytes, int offset, int length)`
`static boolean`	`equals(byte[] left, byte[] right)`
`static boolean`	`equals(byte[] left, int leftOffset, int leftLen, byte[] right, int rightOffset, int rightLen)`
`static byte[]`	`getBytes(ByteBuffer buf)` This method will get a sequence of bytes from pos , but will restore pos after.
`static int`	`hashBytes(byte[] bytes, int length)` Compute hash for binary data.
`static int`	`hashBytes(byte[] bytes, int offset, int length)` Compute hash for binary data.
`static int`	`hashCode(byte[] b)`
`static int`	`hashCode(byte[] b, int length)`
`static int`	`hashCode(byte[] bytes, int offset, int length)`
`static int`	`putBigDecimal(byte[] bytes, int offset, BigDecimal val)` Put a BigDecimal value out to the specified byte array position.
`static int`	`putByte(byte[] bytes, int offset, byte b)` Write a single byte out to the specified byte array position.
`static int`	`putBytes(byte[] tgtBytes, int tgtOffset, byte[] srcBytes, int srcOffset, int srcLength)` Put bytes at the specified byte array position.
`static int`	`putDouble(byte[] bytes, int offset, double d)`
`static int`	`putFloat(byte[] bytes, int offset, float f)`
`static int`	`putInt(byte[] bytes, int offset, int val)` Put an int value out to the specified byte array position.
`static int`	`putLong(byte[] bytes, int offset, long val)` Put a long value out to the specified byte array position.
`static int`	`putShort(byte[] bytes, int offset, short val)` Put a short value out to the specified byte array position.
`static byte[]`	`readByteArray(DataInput in)` Read byte-array written with a WritableableUtils.vint prefix.
`static byte[]`	`readByteArrayThrowsRuntime(DataInput in)` Read byte-array written with a WritableableUtils.vint prefix.
`static long`	`readVLong(byte[] buffer, int offset)` Reads a zero-compressed encoded long from input stream and returns it.
`static boolean`	`startsWith(byte[] bytes, byte[] prefix)` Return true if the byte array on the right is a prefix of the byte array on the left.
`static int`	`stringtoUTF8Bytes(String str, byte[] buffer)` 参考规范： http://tools.ietf.org/html/rfc3629
`static BigDecimal`	`toBigDecimal(byte[] bytes)` Converts a byte array to a BigDecimal
`static BigDecimal`	`toBigDecimal(byte[] bytes, int offset, int length)` Converts a byte array to a BigDecimal value
`static byte`	`toBinaryFromHex(byte ch)` Takes a ASCII digit in the range A-F0-9 and returns the corresponding integer/ordinal value.
`static boolean`	`toBoolean(byte[] b)` Reverses `toBytes(boolean)`
`static boolean`	`toBoolean(byte[] bytes, int offset, int length)`
`static byte`	`toByte(byte[] bytes, int offset, int length)`
`static byte[]`	`toBytes(BigDecimal val)` Convert a BigDecimal value to a byte array
`static byte[]`	`toBytes(boolean b)` Convert a boolean to a byte array.
`static byte[]`	`toBytes(ByteBuffer bb)` Returns a new byte array, copied from the passed ByteBuffer.
`static byte[]`	`toBytes(double d)` Serialize a double as the IEEE 754 double format output.
`static byte[]`	`toBytes(float f)`
`static byte[]`	`toBytes(int val)` Convert an int value to a byte array
`static byte[]`	`toBytes(long val)` Convert a long value to a byte array using big-endian.
`static byte[]`	`toBytes(short val)` Convert a short value to a byte array of `SIZEOF_SHORT` bytes long.
`static byte[]`	`toBytes(String s)` Converts a string to a UTF-8 byte array.
`static byte[]`	`toBytesBinary(String in)`
`static double`	`toDouble(byte[] bytes)`
`static double`	`toDouble(byte[] bytes, int offset)`
`static float`	`toFloat(byte[] bytes)` Presumes float encoded as IEEE 754 floating-point "single format"
`static float`	`toFloat(byte[] bytes, int offset)` Presumes float encoded as IEEE 754 floating-point "single format"
`static int`	`toInt(byte[] bytes)` Converts a byte array to an int value
`static int`	`toInt(byte[] bytes, int offset)` Converts a byte array to an int value
`static int`	`toInt(byte[] bytes, int offset, int length)` Converts a byte array to an int value
`static long`	`toLong(byte[] bytes)` Converts a byte array to a long value.
`static long`	`toLong(byte[] bytes, int offset)` Converts a byte array to a long value.
`static long`	`toLong(byte[] bytes, int offset, int length)` Converts a byte array to a long value.
`static short`	`toShort(byte[] bytes)` Converts a byte array to a short value
`static short`	`toShort(byte[] bytes, int offset)` Converts a byte array to a short value
`static short`	`toShort(byte[] bytes, int offset, int length)` Converts a byte array to a short value
`static String`	`toString(byte[] b)`
`static String`	`toString(byte[] b, int off, int len)` This method will convert utf8 encoded bytes into a string.
`static String`	`toString(byte[] b1, String sep, byte[] b2)` Joins two byte arrays together using a separator.
`static String`	`toStringBinary(byte[] b)` Write a printable representation of a byte array.
`static String`	`toStringBinary(byte[] b, int off, int len)` Write a printable representation of a byte array.
`static String`	`toStringBinary(ByteBuffer buf)` Converts the given byte buffer, from its array offset to its limit, to a string.
`static byte[]`	`vintToBytes(long vint)`
`static int`	`writeByteArray(byte[] tgt, int tgtOffset, byte[] src, int srcOffset, int srcLength)` Write byte-array from src to tgt with a vint length prefix.
`static void`	`writeByteArray(DataOutput out, byte[] b)` Write byte-array with a WritableableUtils.vint prefix.
`static void`	`writeByteArray(DataOutput out, byte[] b, int offset, int length)` Write byte-array to out with a vint length prefix.

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 字段详细资料
  - SIZEOF_BOOLEAN
```
public static final int SIZEOF_BOOLEAN
```
    Size of boolean in bytes
    
    另请参阅:
    
    常量字段值
  - SIZEOF_BYTE
```
public static final int SIZEOF_BYTE
```
    Size of byte in bytes
    
    另请参阅:
    
    常量字段值
  - SIZEOF_CHAR
```
public static final int SIZEOF_CHAR
```
    Size of char in bytes
    
    另请参阅:
    
    常量字段值
  - SIZEOF_DOUBLE
```
public static final int SIZEOF_DOUBLE
```
    Size of double in bytes
    
    另请参阅:
    
    常量字段值
  - SIZEOF_FLOAT
```
public static final int SIZEOF_FLOAT
```
    Size of float in bytes
    
    另请参阅:
    
    常量字段值
  - SIZEOF_INT
```
public static final int SIZEOF_INT
```
    Size of int in bytes
    
    另请参阅:
    
    常量字段值
  - SIZEOF_LONG
```
public static final int SIZEOF_LONG
```
    Size of long in bytes
    
    另请参阅:
    
    常量字段值
  - SIZEOF_SHORT
```
public static final int SIZEOF_SHORT
```
    Size of short in bytes
    
    另请参阅:
    
    常量字段值
  - ESTIMATED_HEAP_TAX
```
public static final int ESTIMATED_HEAP_TAX
```
    Estimate of size cost to pay beyond payload in jvm for instance of byte []. Estimate based on study of jhat and jprofiler numbers.
    
    另请参阅:
    
    常量字段值
- 构造器详细资料
  - Bytes
```
public Bytes()
```
- 方法详细资料
  - readByteArray
```
public static byte[] readByteArray(DataInput in)
                            throws IOException
```
    Read byte-array written with a WritableableUtils.vint prefix.
    
    参数:
    
    in - Input to read from.
    
    返回:
    
    byte array read off in
    
    抛出:
    
    IOException - e
  - readByteArrayThrowsRuntime
```
public static byte[] readByteArrayThrowsRuntime(DataInput in)
```
    Read byte-array written with a WritableableUtils.vint prefix. IOException is converted to a RuntimeException.
    
    参数:
    
    in - Input to read from.
    
    返回:
    
    byte array read off in
  - writeByteArray
```
public static void writeByteArray(DataOutput out,
                                  byte[] b)
                           throws IOException
```
    Write byte-array with a WritableableUtils.vint prefix.
    
    参数:
    
    out - output stream to be written to
    
    b - array to write
    
    抛出:
    
    IOException - e
  - writeByteArray
```
public static void writeByteArray(DataOutput out,
                                  byte[] b,
                                  int offset,
                                  int length)
                           throws IOException
```
    Write byte-array to out with a vint length prefix.
    
    参数:
    
    out - output stream
    
    b - array
    
    offset - offset into array
    
    length - length past offset
    
    抛出:
    
    IOException - e
  - writeByteArray
```
public static int writeByteArray(byte[] tgt,
                                 int tgtOffset,
                                 byte[] src,
                                 int srcOffset,
                                 int srcLength)
```
    Write byte-array from src to tgt with a vint length prefix.
    
    参数:
    
    tgt - target array
    
    tgtOffset - offset into target array
    
    src - source array
    
    srcOffset - source offset
    
    srcLength - source length
    
    返回:
    
    New offset in src array.
  - putBytes
```
public static int putBytes(byte[] tgtBytes,
                           int tgtOffset,
                           byte[] srcBytes,
                           int srcOffset,
                           int srcLength)
```
    Put bytes at the specified byte array position.
    
    参数:
    
    tgtBytes - the byte array
    
    tgtOffset - position in the array
    
    srcBytes - array to write out
    
    srcOffset - source offset
    
    srcLength - source length
    
    返回:
    
    incremented offset
  - putByte
```
public static int putByte(byte[] bytes,
                          int offset,
                          byte b)
```
    Write a single byte out to the specified byte array position.
    
    参数:
    
    bytes - the byte array
    
    offset - position in the array
    
    b - byte to write out
    
    返回:
    
    incremented offset
  - toBytes
```
public static byte[] toBytes(ByteBuffer bb)
```
    Returns a new byte array, copied from the passed ByteBuffer.
    
    参数:
    
    bb - A ByteBuffer
    
    返回:
    
    the byte array
  - toString
```
public static String toString(byte[] b)
```
    参数:
    
    b - Presumed UTF-8 encoded byte array.
    
    返回:
    
    String made from b
  - toString
```
public static String toString(byte[] b1,
                              String sep,
                              byte[] b2)
```
    Joins two byte arrays together using a separator.
    
    参数:
    
    b1 - The first byte array.
    
    sep - The separator to use.
    
    b2 - The second byte array.
    
    返回:
    
    String b1+sep+b2 value
  - toString
```
public static String toString(byte[] b,
                              int off,
                              int len)
```
    This method will convert utf8 encoded bytes into a string. If an UnsupportedEncodingException occurs, this method will eat it and return null instead.
    
    参数:
    
    b - Presumed UTF-8 encoded byte array.
    
    off - offset into array
    
    len - length of utf-8 sequence
    
    返回:
    
    String made from b or null
  - copyBytes
```
public static byte[] copyBytes(byte[] bytes,
                               int offset,
                               int length)
```
  - toStringBinary
```
public static String toStringBinary(byte[] b)
```
    Write a printable representation of a byte array.
    
    参数:
    
    b - byte array
    
    返回:
    
    string
    
    另请参阅:
    
    toStringBinary(byte[], int, int)
  - toStringBinary
```
public static String toStringBinary(ByteBuffer buf)
```
    Converts the given byte buffer, from its array offset to its limit, to a string. The position and the mark are ignored.
    
    参数:
    
    buf - a byte buffer
    
    返回:
    
    a string representation of the buffer's binary contents
  - toStringBinary
```
public static String toStringBinary(byte[] b,
                                    int off,
                                    int len)
```
    Write a printable representation of a byte array. Non-printable characters are hex escaped in the format \\x%02X, eg: \x00 \x05 etc
    
    参数:
    
    b - array to write out
    
    off - offset to start at
    
    len - length to write
    
    返回:
    
    string output
  - toBinaryFromHex
```
public static byte toBinaryFromHex(byte ch)
```
    Takes a ASCII digit in the range A-F0-9 and returns the corresponding integer/ordinal value.
    
    参数:
    
    ch - The hex digit.
    
    返回:
    
    The converted hex value as a byte.
  - toBytesBinary
```
public static byte[] toBytesBinary(String in)
```
  - toBytes
```
public static byte[] toBytes(String s)
```
    Converts a string to a UTF-8 byte array.
    
    参数:
    
    s - string
    
    返回:
    
    the byte array
  - toBytes
```
public static byte[] toBytes(boolean b)
```
    Convert a boolean to a byte array. True becomes -1 and false becomes 0.
    
    参数:
    
    b - value
    
    返回:
    
    b encoded in a byte array.
  - toBoolean
```
public static boolean toBoolean(byte[] b)
```
    Reverses toBytes(boolean)
    
    参数:
    
    b - array
    
    返回:
    
    True or false.
  - toBoolean
```
public static boolean toBoolean(byte[] bytes,
                                int offset,
                                int length)
```
  - toBytes
```
public static byte[] toBytes(long val)
```
    Convert a long value to a byte array using big-endian.
    
    参数:
    
    val - value to convert
    
    返回:
    
    the byte array
  - toLong
```
public static long toLong(byte[] bytes)
```
    Converts a byte array to a long value. Reverses toBytes(long)
    
    参数:
    
    bytes - array
    
    返回:
    
    the long value
  - toLong
```
public static long toLong(byte[] bytes,
                          int offset)
```
    Converts a byte array to a long value. Assumes there will be SIZEOF_LONG bytes available.
    
    参数:
    
    bytes - bytes
    
    offset - offset
    
    返回:
    
    the long value
  - toLong
```
public static long toLong(byte[] bytes,
                          int offset,
                          int length)
```
    Converts a byte array to a long value.
    
    参数:
    
    bytes - array of bytes
    
    offset - offset into array
    
    length - length of data (must be SIZEOF_LONG)
    
    返回:
    
    the long value
    
    抛出:
    
    IllegalArgumentException - if length is not SIZEOF_LONG or if there's not enough room in the array at the offset indicated.
  - putLong
```
public static int putLong(byte[] bytes,
                          int offset,
                          long val)
```
    Put a long value out to the specified byte array position.
    
    参数:
    
    bytes - the byte array
    
    offset - position in the array
    
    val - long to write out
    
    返回:
    
    incremented offset
    
    抛出:
    
    IllegalArgumentException - if the byte array given doesn't have enough room at the offset specified.
  - toFloat
```
public static float toFloat(byte[] bytes)
```
    Presumes float encoded as IEEE 754 floating-point "single format"
    
    参数:
    
    bytes - byte array
    
    返回:
    
    Float made from passed byte array.
  - toFloat
```
public static float toFloat(byte[] bytes,
                            int offset)
```
    Presumes float encoded as IEEE 754 floating-point "single format"
    
    参数:
    
    bytes - array to convert
    
    offset - offset into array
    
    返回:
    
    Float made from passed byte array.
  - putFloat
```
public static int putFloat(byte[] bytes,
                           int offset,
                           float f)
```
    参数:
    
    bytes - byte array
    
    offset - offset to write to
    
    f - float value
    
    返回:
    
    New offset in bytes
  - toBytes
```
public static byte[] toBytes(float f)
```
    参数:
    
    f - float value
    
    返回:
    
    the float represented as byte []
  - toDouble
```
public static double toDouble(byte[] bytes)
```
    参数:
    
    bytes - byte array
    
    返回:
    
    Return double made from passed bytes.
  - toDouble
```
public static double toDouble(byte[] bytes,
                              int offset)
```
    参数:
    
    bytes - byte array
    
    offset - offset where double is
    
    返回:
    
    Return double made from passed bytes.
  - putDouble
```
public static int putDouble(byte[] bytes,
                            int offset,
                            double d)
```
    参数:
    
    bytes - byte array
    
    offset - offset to write to
    
    d - value
    
    返回:
    
    New offset into array bytes
  - toBytes
```
public static byte[] toBytes(double d)
```
    Serialize a double as the IEEE 754 double format output. The resultant array will be 8 bytes long.
    
    参数:
    
    d - value
    
    返回:
    
    the double represented as byte []
  - toBytes
```
public static byte[] toBytes(int val)
```
    Convert an int value to a byte array
    
    参数:
    
    val - value
    
    返回:
    
    the byte array
  - toInt
```
public static int toInt(byte[] bytes)
```
    Converts a byte array to an int value
    
    参数:
    
    bytes - byte array
    
    返回:
    
    the int value
  - toInt
```
public static int toInt(byte[] bytes,
                        int offset)
```
    Converts a byte array to an int value
    
    参数:
    
    bytes - byte array
    
    offset - offset into array
    
    返回:
    
    the int value
  - toInt
```
public static int toInt(byte[] bytes,
                        int offset,
                        int length)
```
    Converts a byte array to an int value
    
    参数:
    
    bytes - byte array
    
    offset - offset into array
    
    length - length of int (has to be SIZEOF_INT)
    
    返回:
    
    the int value
    
    抛出:
    
    IllegalArgumentException - if length is not SIZEOF_INT or if there's not enough room in the array at the offset indicated.
  - putInt
```
public static int putInt(byte[] bytes,
                         int offset,
                         int val)
```
    Put an int value out to the specified byte array position.
    
    参数:
    
    bytes - the byte array
    
    offset - position in the array
    
    val - int to write out
    
    返回:
    
    incremented offset
    
    抛出:
    
    IllegalArgumentException - if the byte array given doesn't have enough room at the offset specified.
  - toBytes
```
public static byte[] toBytes(short val)
```
    Convert a short value to a byte array of SIZEOF_SHORT bytes long.
    
    参数:
    
    val - value
    
    返回:
    
    the byte array
  - toShort
```
public static short toShort(byte[] bytes)
```
    Converts a byte array to a short value
    
    参数:
    
    bytes - byte array
    
    返回:
    
    the short value
  - toShort
```
public static short toShort(byte[] bytes,
                            int offset)
```
    Converts a byte array to a short value
    
    参数:
    
    bytes - byte array
    
    offset - offset into array
    
    返回:
    
    the short value
  - toShort
```
public static short toShort(byte[] bytes,
                            int offset,
                            int length)
```
    Converts a byte array to a short value
    
    参数:
    
    bytes - byte array
    
    offset - offset into array
    
    length - length, has to be SIZEOF_SHORT
    
    返回:
    
    the short value
    
    抛出:
    
    IllegalArgumentException - if length is not SIZEOF_SHORT or if there's not enough room in the array at the offset indicated.
  - getBytes
```
public static byte[] getBytes(ByteBuffer buf)
```
    This method will get a sequence of bytes from pos , but will restore pos after.
    
    参数:
    
    buf -
    
    返回:
    
    byte array
  - putShort
```
public static int putShort(byte[] bytes,
                           int offset,
                           short val)
```
    Put a short value out to the specified byte array position.
    
    参数:
    
    bytes - the byte array
    
    offset - position in the array
    
    val - short to write out
    
    返回:
    
    incremented offset
    
    抛出:
    
    IllegalArgumentException - if the byte array given doesn't have enough room at the offset specified.
  - toByte
```
public static byte toByte(byte[] bytes,
                          int offset,
                          int length)
```
  - toBytes
```
public static byte[] toBytes(BigDecimal val)
```
    Convert a BigDecimal value to a byte array
    
    参数:
    
    val -
    
    返回:
    
    the byte array
  - toBigDecimal
```
public static BigDecimal toBigDecimal(byte[] bytes)
```
    Converts a byte array to a BigDecimal
    
    参数:
    
    bytes -
    
    返回:
    
    the char value
  - toBigDecimal
```
public static BigDecimal toBigDecimal(byte[] bytes,
                                      int offset,
                                      int length)
```
    Converts a byte array to a BigDecimal value
    
    参数:
    
    bytes -
    
    offset -
    
    length -
    
    返回:
    
    the char value
  - putBigDecimal
```
public static int putBigDecimal(byte[] bytes,
                                int offset,
                                BigDecimal val)
```
    Put a BigDecimal value out to the specified byte array position.
    
    参数:
    
    bytes - the byte array
    
    offset - position in the array
    
    val - BigDecimal to write out
    
    返回:
    
    incremented offset
  - vintToBytes
```
public static byte[] vintToBytes(long vint)
```
    参数:
    
    vint - Integer to make a vint of.
    
    返回:
    
    Vint as bytes array.
  - bytesToVint
```
public static long bytesToVint(byte[] buffer)
```
    参数:
    
    buffer - buffer to convert
    
    返回:
    
    vint bytes as an integer.
  - readVLong
```
public static long readVLong(byte[] buffer,
                             int offset)
                      throws IOException
```
    Reads a zero-compressed encoded long from input stream and returns it.
    
    参数:
    
    buffer - Binary array
    
    offset - Offset into array at which vint begins.
    
    返回:
    
    deserialized long from stream.
    
    抛出:
    
    IOException - e
  - compareTo
```
public static int compareTo(byte[] left,
                            byte[] right)
```
    参数:
    
    left - left operand
    
    right - right operand
    
    返回:
    
    int 相等时返回0，left小于right时返回负值
  - compareTo
```
public static int compareTo(byte[] buffer1,
                            int offset1,
                            int length1,
                            byte[] buffer2,
                            int offset2,
                            int length2)
```
    Lexicographically compare two arrays.
    
    参数:
    
    buffer1 - left operand
    
    buffer2 - right operand
    
    offset1 - Where to start comparing in the left buffer
    
    offset2 - Where to start comparing in the right buffer
    
    length1 - How much to compare from the left buffer
    
    length2 - How much to compare from the right buffer
    
    返回:
    
    相等时返回0，left小于right时返回负值
  - compareByteArrayInLexOrder
```
public static int compareByteArrayInLexOrder(byte[] buffer1,
                                             int offset1,
                                             int length1,
                                             byte[] buffer2,
                                             int offset2,
                                             int length2)
```
  - equals
```
public static boolean equals(byte[] left,
                             byte[] right)
```
    参数:
    
    left - left operand
    
    right - right operand
    
    返回:
    
    True if equal
  - equals
```
public static boolean equals(byte[] left,
                             int leftOffset,
                             int leftLen,
                             byte[] right,
                             int rightOffset,
                             int rightLen)
```
  - startsWith
```
public static boolean startsWith(byte[] bytes,
                                 byte[] prefix)
```
    Return true if the byte array on the right is a prefix of the byte array on the left.
  - hashCode
```
public static int hashCode(byte[] b)
```
  - hashCode
```
public static int hashCode(byte[] b,
                           int length)
```
  - hashBytes
```
public static int hashBytes(byte[] bytes,
                            int offset,
                            int length)
```
    Compute hash for binary data.
  - hashBytes
```
public static int hashBytes(byte[] bytes,
                            int length)
```
    Compute hash for binary data.
  - hashCode
```
public static int hashCode(byte[] bytes,
                           int offset,
                           int length)
```
    参数:
    
    bytes - array to hash
    
    offset - offset to start from
    
    length - length to hash
  - stringtoUTF8Bytes
```
public static int stringtoUTF8Bytes(String str,
                                    byte[] buffer)
```
    参考规范： http://tools.ietf.org/html/rfc3629

类 Bytes

嵌套类概要

字段概要

构造器概要

方法概要

从类继承的方法 java.lang.Object

字段详细资料

SIZEOF_BOOLEAN

SIZEOF_BYTE

SIZEOF_CHAR

SIZEOF_DOUBLE

SIZEOF_FLOAT

SIZEOF_INT

SIZEOF_LONG

SIZEOF_SHORT

ESTIMATED_HEAP_TAX

构造器详细资料

Bytes

方法详细资料

readByteArray

readByteArrayThrowsRuntime

writeByteArray

writeByteArray

writeByteArray

putBytes

putByte

toBytes

toString

toString

toString

copyBytes

toStringBinary

toStringBinary

toStringBinary

toBinaryFromHex

toBytesBinary

toBytes

toBytes

toBoolean

toBoolean

toBytes

toLong

toLong

toLong

putLong

toFloat

toFloat

putFloat

toBytes

toDouble

toDouble

putDouble

toBytes

toBytes

toInt

toInt

toInt

putInt

toBytes

toShort

toShort

toShort

getBytes

putShort

toByte

toBytes

toBigDecimal

toBigDecimal

putBigDecimal

vintToBytes

bytesToVint

readVLong

compareTo

compareTo

compareByteArrayInLexOrder

equals

equals

startsWith

hashCode

hashCode