public static byte[] getByteArray(byte[] data,
    int offset,
    int size) 
{
        byte[] copy = new byte[size];
        System.arraycopy(data, offset, copy, 0, size);
        return copy;
}

Copy a portion of a byte array

 public static double getDouble(byte[] data) 
{
        return getDouble(data, 0);
}

get a double value from the beginning of a byte array

 public static double getDouble(byte[] data,
    int offset) 
{
        return Double.longBitsToDouble(getNumber(data, offset, DOUBLE_SIZE));
}

get a double value from a byte array, reads it in little endian format then converts the resulting revolting IEEE 754 (curse them) floating point number to a happy java double

 public static int getInt(byte[] data) 
{
        return getInt(data, 0);
}

get an int value from the beginning of a byte array

 public static int getInt(byte[] data,
    int offset) 
{
        return (int) getNumber(data, offset, INT_SIZE);
}

get an int value from a byte array

 public static long getLong(byte[] data) 
{
        return getLong(data, 0);
}

get a long value from the beginning of a byte array

 public static long getLong(byte[] data,
    int offset) 
{
        return getNumber(data, offset, LONG_SIZE);
}

get a long value from a byte array

 public static short getShort(byte[] data) 
{
        return getShort(data, 0);
}

get a short value from the beginning of a byte array

 public static short getShort(byte[] data,
    int offset) 
{
        return (short) getNumber(data, offset, SHORT_SIZE);
}

get a short value from a byte array

 public static short[] getShortArray(byte[] data,
    int offset) 
{
        int size = (int) getNumber(data, offset, SHORT_SIZE);
        short[] results = getSimpleShortArray(data, offset, size);
        return results;
}

get a short array from a byte array. The short array is assumed to start with a word describing the length of the array.

 public static short[] getSimpleShortArray(byte[] data,
    int offset,
    int size) 
{
        short[] results = new short[size];
        for (int i = 0; i <  size; i++) {
            results[i] = getShort(data, offset + 2 + (i * 2));
        }
        return results;
}

get a short array from a byte array.

 public static long getUInt(byte[] data) 
{
	return getUInt(data,0);
}

get an unsigned int value from a byte array

 public static long getUInt(byte[] data,
    int offset) 
{
        int num = (int) getNumber(data, offset, INT_SIZE);
        long retNum;
        if (num <  0) {
            retNum = ((long) Integer.MAX_VALUE + 1) * 2 + num;
        } else {
            retNum = num;
        }
        return retNum;
}

get an unsigned int value from a byte array

 public static long getULong(byte[] data,
    int offset) 
{
        int num = (int) getNumber(data, offset, LONG_SIZE);
        long retNum;
        if (num <  0)
            retNum = ((long) Integer.MAX_VALUE + 1) * 2 + num;
        else
            retNum = num;
        return retNum;
}

Gets an unsigned int value (8 bytes) from a byte array.

 public static int getUShort(byte[] data) 
{
        return getUShort(data, 0);
}

get an unsigned short value from the beginning of a byte array

 public static int getUShort(byte[] data,
    int offset) 
{
        short num = (short) getNumber(data, offset, SHORT_SIZE);
        int retNum;
        if (num <  0) {
            retNum = (Short.MAX_VALUE + 1) * 2 + num;
        } else {
            retNum = num;
        }
        return retNum;
}

get an unsigned short value from a byte array

 public static int getUnsignedByte(byte[] data) 
{
        return getUnsignedByte(data, 0);
}

get the unsigned value of a byte.

 public static int getUnsignedByte(byte[] data,
    int offset) 
{
        return (int) getNumber(data, offset, BYTE_SIZE);
}

get the unsigned value of a byte.

 public static  void putByte(byte[] data,
    int offset,
    int value) 
{
        putNumber(data, offset, value, LittleEndianConsts.BYTE_SIZE);
}

executes:

data[offset] = (byte)value;

Added for consistency with other put~() methods

 public static  void putDouble(byte[] data,
    double value) 
{
        putDouble(data, 0, value);
}

put a double value into beginning of a byte array

 public static  void putDouble(byte[] data,
    int offset,
    double value) 
{
        // Excel likes NaN to be a specific value.
        if (Double.isNaN(value))
            putNumber(data, offset, -276939487313920L, DOUBLE_SIZE);
        else
            putNumber(data, offset, Double.doubleToLongBits(value), DOUBLE_SIZE);
}

put a double value into a byte array

 public static  void putInt(byte[] data,
    int value) 
{
        putInt(data, 0, value);
}

put an int value into beginning of a byte array

 public static  void putInt(byte[] data,
    int offset,
    int value) 
{
        putNumber(data, offset, value, INT_SIZE);
}

put an int value into a byte array

 public static  void putLong(byte[] data,
    long value) 
{
        putLong(data, 0, value);
}

put a long value into beginning of a byte array

 public static  void putLong(byte[] data,
    int offset,
    long value) 
{
        putNumber(data, offset, value, LONG_SIZE);
}

put a long value into a byte array

 public static  void putShort(byte[] data,
    short value) 
{
        putShort(data, 0, value);
}

put a short value into beginning of a byte array

 public static  void putShort(byte[] data,
    int offset,
    short value) 
{
        putNumber(data, offset, value, SHORT_SIZE);
}

put a short value into a byte array

 public static  void putShortArray(byte[] data,
    int offset,
    short[] value) 
{
        putNumber(data, offset, value.length, SHORT_SIZE);
        for (int i = 0; i <  value.length; i++) {
            putNumber(data, offset + 2 + (i * 2), value[i], SHORT_SIZE);
        }
}

put a array of shorts into a byte array

 public static  void putUShort(byte[] data,
    int offset,
    int value) 
{
        putNumber(data, offset, value, SHORT_SIZE);
}

put an unsigned short value into a byte array

 public static byte[] readFromStream(InputStream stream,
    int size) throws IOException, LittleEndian.BufferUnderrunException 
{
        byte[] buffer = new byte[size];
        int count = stream.read(buffer);
        if (count == -1) {
            // return a zero-filled buffer
            Arrays.fill(buffer, (byte) 0);
        } else if (count != size) {
            throw new BufferUnderrunException();
        }
        return buffer;
}

Read the appropriate number of bytes from the stream and return them to the caller.

However, for the purposes of the POI project, this risk is deemed negligible. It is, however, so noted.

 public static int readInt(InputStream stream) throws IOException, LittleEndian.BufferUnderrunException 
{
        return getInt(readFromStream(stream, INT_SIZE));
}

get an int value from an InputStream

 public static long readLong(InputStream stream) throws IOException, LittleEndian.BufferUnderrunException 
{
        return getLong(readFromStream(stream, LONG_SIZE));
}

get a long value from an InputStream

 public static short readShort(InputStream stream) throws IOException, LittleEndian.BufferUnderrunException 
{
        return getShort(readFromStream(stream, SHORT_SIZE));
}

get a short value from an InputStream

 public static int ubyteToInt(byte b) 
{
        return ((b & 0x80) == 0 ? (int) b : (b & (byte) 0x7f) + 0x80);
}

Convert an 'unsigned' byte to an integer. ie, don't carry across the sign.