Byte represent primitive byte
* values.
*
* Additionally, this class provides various helper functions and variables
* useful to bytes.
*
* @author Paul Fisher
* @author John Keiser
* @author Per Bothner
* @author Eric Blake (ebb9@email.byu.edu)
* @author Tom Tromey (tromey@redhat.com)
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
* @since 1.1
* @status updated to 1.5
*/
public final class Byte extends Number implements Comparablebyte can represent is -128 (or
* -27).
*/
public static final byte MIN_VALUE = -128;
/**
* The maximum value a byte can represent is 127 (or
* 27 - 1).
*/
public static final byte MAX_VALUE = 127;
/**
* The primitive type byte is represented by this
* Class object.
*/
public static final Classbyte.
* @since 1.5
*/
public static final int SIZE = 8;
// This caches Byte values, and is used by boxing conversions via
// valueOf(). We're required to cache all possible values here.
private static Byte[] byteCache = new Byte[MAX_VALUE - MIN_VALUE + 1];
static
{
for (int i=MIN_VALUE; i <= MAX_VALUE; i++)
byteCache[i - MIN_VALUE] = new Byte((byte) i);
}
/**
* The immutable value of this Byte.
*
* @serial the wrapped byte
*/
private final byte value;
/**
* Create a Byte object representing the value of the
* byte argument.
*
* @param value the value to use
*/
public Byte(byte value)
{
this.value = value;
}
/**
* Create a Byte object representing the value specified
* by the String argument
*
* @param s the string to convert
* @throws NumberFormatException if the String does not contain a byte
* @see #valueOf(String)
*/
public Byte(String s)
{
value = parseByte(s, 10);
}
/**
* Converts the byte to a String and assumes
* a radix of 10.
*
* @param b the byte to convert to String
* @return the String representation of the argument
*/
public static String toString(byte b)
{
return String.valueOf(b);
}
/**
* Converts the specified String into a byte.
* This function assumes a radix of 10.
*
* @param s the String to convert
* @return the byte value of s
* @throws NumberFormatException if s cannot be parsed as a
* byte
* @see #parseByte(String)
*/
public static byte parseByte(String s)
{
return parseByte(s, 10);
}
/**
* Converts the specified String into an int
* using the specified radix (base). The string must not be null
* or empty. It may begin with an optional '-', which will negate the answer,
* provided that there are also valid digits. Each digit is parsed as if by
* Character.digit(d, radix), and must be in the range
* 0 to radix - 1. Finally, the result must be
* within MIN_VALUE to MAX_VALUE, inclusive.
* Unlike Double.parseDouble, you may not have a leading '+'.
*
* @param s the String to convert
* @param radix the radix (base) to use in the conversion
* @return the String argument converted to byte
* @throws NumberFormatException if s cannot be parsed as a
* byte
*/
public static byte parseByte(String s, int radix)
{
int i = Integer.parseInt(s, radix, false);
if ((byte) i != i)
throw new NumberFormatException();
return (byte) i;
}
/**
* Creates a new Byte object using the String
* and specified radix (base).
*
* @param s the String to convert
* @param radix the radix (base) to convert with
* @return the new Byte
* @throws NumberFormatException if s cannot be parsed as a
* byte
* @see #parseByte(String, int)
*/
public static Byte valueOf(String s, int radix)
{
return valueOf(parseByte(s, radix));
}
/**
* Creates a new Byte object using the String,
* assuming a radix of 10.
*
* @param s the String to convert
* @return the new Byte
* @throws NumberFormatException if s cannot be parsed as a
* byte
* @see #Byte(String)
* @see #parseByte(String)
*/
public static Byte valueOf(String s)
{
return valueOf(parseByte(s, 10));
}
/**
* Returns a Byte object wrapping the value.
* In contrast to the Byte constructor, this method
* will cache some values. It is used by boxing conversion.
*
* @param val the value to wrap
* @return the Byte
*/
public static Byte valueOf(byte val)
{
return byteCache[val - MIN_VALUE];
}
/**
* Convert the specified String into a Byte.
* The String may represent decimal, hexadecimal, or
* octal numbers.
*
* The extended BNF grammar is as follows:
*
* DecodableString: * ( [* Finally, the value must be in the range-] DecimalNumber ) * | ( [-] (0x|0X* |#) { HexDigit }+ ) * | ( [-]0{ OctalDigit } ) * DecimalNumber: * DecimalDigit except '0' { DecimalDigit } * DecimalDigit: * Character.digit(d, 10) has value 0 to 9 * OctalDigit: * Character.digit(d, 8) has value 0 to 7 * DecimalDigit: * Character.digit(d, 16) has value 0 to 15 *
MIN_VALUE to
* MAX_VALUE, or an exception is thrown.
*
* @param s the String to interpret
* @return the value of the String as a Byte
* @throws NumberFormatException if s cannot be parsed as a
* byte
* @throws NullPointerException if s is null
* @see Integer#decode(String)
*/
public static Byte decode(String s)
{
int i = Integer.parseInt(s, 10, true);
if ((byte) i != i)
throw new NumberFormatException();
return valueOf((byte) i);
}
/**
* Return the value of this Byte.
*
* @return the byte value
*/
public byte byteValue()
{
return value;
}
/**
* Return the value of this Byte as a short.
*
* @return the short value
*/
public short shortValue()
{
return value;
}
/**
* Return the value of this Byte as an int.
*
* @return the int value
*/
public int intValue()
{
return value;
}
/**
* Return the value of this Byte as a long.
*
* @return the long value
*/
public long longValue()
{
return value;
}
/**
* Return the value of this Byte as a float.
*
* @return the float value
*/
public float floatValue()
{
return value;
}
/**
* Return the value of this Byte as a double.
*
* @return the double value
*/
public double doubleValue()
{
return value;
}
/**
* Converts the Byte value to a String and
* assumes a radix of 10.
*
* @return the String representation of this Byte
* @see Integer#toString()
*/
public String toString()
{
return String.valueOf(value);
}
/**
* Return a hashcode representing this Object. Byte's hash
* code is simply its value.
*
* @return this Object's hash code
*/
public int hashCode()
{
return value;
}
/**
* Returns true if obj is an instance of
* Byte and represents the same byte value.
*
* @param obj the object to compare
* @return whether these Objects are semantically equal
*/
public boolean equals(Object obj)
{
return obj instanceof Byte && value == ((Byte) obj).value;
}
/**
* Compare two Bytes numerically by comparing their byte values.
* The result is positive if the first is greater, negative if the second
* is greater, and 0 if the two are equal.
*
* @param b the Byte to compare
* @return the comparison
* @since 1.2
*/
public int compareTo(Byte b)
{
return value - b.value;
}
}