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
* @since JDK 1.0
*/
public final class Byte extends Number implements Comparable
{
static final long serialVersionUID = -7183698231559129828L;
/**
* The minimum value a byte can represent is -128.
*/
public static final byte MIN_VALUE = -128;
/**
* The maximum value a byte can represent is 127.
*/
public static final byte MAX_VALUE = 127;
/**
* The primitive type byte is represented by this
* Class object.
*/
public static final Class TYPE = VMClassLoader.getPrimitiveClass('B');
/**
* The immutable value of this 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.
*/
public Byte(String s) throws NumberFormatException
{
value = parseByte(s, 10);
}
/**
* Return a hashcode representing this Object.
*
* Byte's hash code is calculated by simply returning 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.
* @return whether these Objects are semantically equal.
*/
public boolean equals(Object obj)
{
return ((obj instanceof Byte) && (value == ((Byte)obj).byteValue()));
}
/**
* Converts the byte to a String and assumes
* a radix of 10.
* @param i the byte to convert to String
* @return the String representation of the argument.
*/
public static String toString(byte i)
{
return Integer.toString ((int) i);
}
/**
* Converts the Byte value to a String and
* assumes a radix of 10.
* @return the String representation of this Byte.
*/
public String toString()
{
return Integer.toString ((int) value);
}
/**
* Creates a new Byte object using the String,
* assuming a radix of 10.
* @param s the String to convert.
* @return the new Byte.
* @see #Byte(java.lang.String)
* @see #parseByte(java.lang.String)
* @exception NumberFormatException thrown if the String
* cannot be parsed as a byte.
*/
public static Byte valueOf(String s) throws NumberFormatException
{
return new Byte(parseByte(s));
}
/**
* 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.
* @see #parseByte(java.lang.String,int)
* @exception NumberFormatException thrown if the String
* cannot be parsed as a byte.
*/
public static Byte valueOf(String s, int radix)
throws NumberFormatException
{
return new Byte(parseByte(s, radix));
}
/**
* 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 the String
* argument.
* @exception NumberFormatException thrown if the String
* cannot be parsed as a byte.
*/
public static byte parseByte(String s) throws NumberFormatException
{
return parseByte(s, 10);
}
/**
* Converts the specified String into a byte
* using the specified radix (base).
*
* @param str the String to convert
* @param radix the radix (base) to use in the conversion
* @return the String argument converted to byte.
* @exception NumberFormatException thrown if the String
* cannot be parsed as a byte.
*/
public static byte parseByte(String str, int radix)
throws NumberFormatException
{
int i = Integer.parseInt(str, radix);
if (i < MIN_VALUE || i > MAX_VALUE)
throw new NumberFormatException();
return (byte) i;
}
/**
* Convert the specified String into a Byte.
* The String may represent decimal, hexadecimal, or
* octal numbers.
*
* The String argument is interpreted based on the leading
* characters. Depending on what the String begins with, the base will be
* interpreted differently:
*
* | Leading Characters | Base |
|---|---|
| # | 16 |
| 0x | 16 |
| 0X | 16 |
| 0 | 8 |
| Anything Else | 10 |
String to interpret.
* @return the value of the String as a Byte.
* @exception NumberFormatException thrown if the String
* cannot be parsed as a byte.
*/
public static Byte decode(String str) throws NumberFormatException
{
int i = (Integer.decode(str)).intValue();
if (i < MIN_VALUE || i > MAX_VALUE)
throw new NumberFormatException();
return new Byte((byte) i);
}
/** Return the value of this Byte as an short.
** @return the value of this Byte as an short.
**/
public byte byteValue()
{
return value;
}
/** Return the value of this Byte as an short.
** @return the value of this Byte as an short.
**/
public short shortValue()
{
return value;
}
/** Return the value of this Byte as an int.
** @return the value of this Byte as an int.
**/
public int intValue()
{
return value;
}
/** Return the value of this Byte as a long.
** @return the value of this Byte as a long.
**/
public long longValue()
{
return value;
}
/** Return the value of this Byte as a float.
** @return the value of this Byte as a float.
**/
public float floatValue()
{
return value;
}
/** Return the value of this Byte as a double.
** @return the value of this Byte as a double.
**/
public double doubleValue()
{
return value;
}
/**
* Compare two Bytes numerically by comparing their
* byte values.
* @return a positive value if this Byte is greater
* in value than the argument Byte; a negative value
* if this Byte is smaller in value than the argument
* Byte; and 0, zero, if this
* Byte is equal in value to the argument
* Byte.
*/
public int compareTo(Byte b)
{
return (int)(value - b.byteValue());
}
/**
* Behaves like compareTo(java.lang.Byte) unless the Object
* is not a Byte. Then it throws a
* ClassCastException.
* @exception ClassCastException if the argument is not a
* Byte.
*/
public int compareTo(Object o)
{
return compareTo((Byte)o);
}
}