*java.lang.Byte* *Byte* The Byte class wraps a value of primitive type
byte in
public final class Byte
extends |java.lang.Number|
implements |java.lang.Comparable|
|java.lang.Byte_Description|
|java.lang.Byte_Fields|
|java.lang.Byte_Constructors|
|java.lang.Byte_Methods|
================================================================================
*java.lang.Byte_Fields*
|byte_java.lang.Byte.MAX_VALUE|
|byte_java.lang.Byte.MIN_VALUE|
|int_java.lang.Byte.SIZE|
|java.lang.Class<java.lang.Byte>_java.lang.Byte.TYPE|
*java.lang.Byte_Constructors*
|java.lang.Byte(byte)|Constructs a newly allocated Byte object that represents
|java.lang.Byte(String)|Constructs a newly allocated Byte object that represen
*java.lang.Byte_Methods*
|java.lang.Byte.byteValue()|Returns the value of this Byte as a byte.
|java.lang.Byte.compareTo(Byte)|Compares two Byte objects numerically.
|java.lang.Byte.decode(String)|Decodes a String into a Byte.
|java.lang.Byte.doubleValue()|Returns the value of this Byte as a double.
|java.lang.Byte.equals(Object)|Compares this object to the specified object.
|java.lang.Byte.floatValue()|Returns the value of this Byte as a float.
|java.lang.Byte.hashCode()|Returns a hash code for this Byte.
|java.lang.Byte.intValue()|Returns the value of this Byte as an int.
|java.lang.Byte.longValue()|Returns the value of this Byte as a long.
|java.lang.Byte.parseByte(String)|Parses the string argument as a signed decima
|java.lang.Byte.parseByte(String,int)|Parses the string argument as a signed by
|java.lang.Byte.shortValue()|Returns the value of this Byte as a short.
|java.lang.Byte.toString()|Returns a String object representing this Byte's va
|java.lang.Byte.toString(byte)|Returns a new String object representing the sp
|java.lang.Byte.valueOf(byte)|Returns a Byte instance representing the specifie
|java.lang.Byte.valueOf(String)|Returns a Byte object holding the value given
|java.lang.Byte.valueOf(String,int)|Returns a Byte object holding the value ex
*java.lang.Byte_Description*
The Byte class wraps a value of primitive type byte in an object. An object of
type Byte contains a single field whose type is byte.
In addition, this class provides several methods for converting a byte to a
String and a String to a byte, as well as other constants and methods useful
when dealing with a byte.
*byte_java.lang.Byte.MAX_VALUE*
A constant holding the maximum value a byte can have, 27-1.
*byte_java.lang.Byte.MIN_VALUE*
A constant holding the minimum value a byte can have, -27.
*int_java.lang.Byte.SIZE*
The number of bits used to represent a byte value in two's complement binary
form.
*java.lang.Class<java.lang.Byte>_java.lang.Byte.TYPE*
The Class instance representing the primitive type byte.
*java.lang.Byte(byte)*
public Byte(byte value)
Constructs a newly allocated Byte object that represents the specified byte
value.
value - the value to be represented by the Byte.
*java.lang.Byte(String)*
public Byte(java.lang.String s)
throws |java.lang.NumberFormatException|
Constructs a newly allocated Byte object that represents the byte value
indicated by the String parameter. The string is converted to a byte value in
exactly the manner used by the parseByte method for radix 10.
s - the String to be converted to a Byte
*java.lang.Byte.byteValue()*
public byte byteValue()
Returns the value of this Byte as a byte.
*java.lang.Byte.compareTo(Byte)*
public int compareTo(java.lang.Byte anotherByte)
Compares two Byte objects numerically.
anotherByte - the Byte to be compared.
Returns: the value 0 if this Byte is equal to the argument Byte; a value less than 0 if
this Byte is numerically less than the argument Byte; and a value
greater than 0 if this Byte is numerically greater than the
argument Byte (signed comparison).
*java.lang.Byte.decode(String)*
public static |java.lang.Byte| decode(java.lang.String nm)
throws |java.lang.NumberFormatException|
Decodes a String into a Byte. Accepts decimal, hexadecimal, and octal numbers
given by the following grammar:
DecodableString: Signopt DecimalNumeral Signopt 0x HexDigits Signopt 0X
HexDigits Signopt # HexDigits Signopt 0 OctalDigits
Sign: -
DecimalNumeral, HexDigits, and OctalDigits are defined in 3.10.1 of the Java
Language Specification.
The sequence of characters following an (optional) negative sign and/or radix
specifier (0x, 0X, #, or leading zero) is parsed as by the Byte.parseByte
method with the indicated radix (10, 16, or 8). This sequence of characters
must represent a positive value or a (|java.lang.NumberFormatException|) will
be thrown. The result is negated if first character of the specified String is
the minus sign. No whitespace characters are permitted in the String.
nm - the String to decode.
Returns: a Byte object holding the byte value represented by nm
*java.lang.Byte.doubleValue()*
public double doubleValue()
Returns the value of this Byte as a double.
*java.lang.Byte.equals(Object)*
public boolean equals(java.lang.Object obj)
Compares this object to the specified object. The result is true if and only if
the argument is not null and is a Byte object that contains the same byte value
as this object.
obj - the object to compare with
Returns: true if the objects are the same; false otherwise.
*java.lang.Byte.floatValue()*
public float floatValue()
Returns the value of this Byte as a float.
*java.lang.Byte.hashCode()*
public int hashCode()
Returns a hash code for this Byte.
*java.lang.Byte.intValue()*
public int intValue()
Returns the value of this Byte as an int.
*java.lang.Byte.longValue()*
public long longValue()
Returns the value of this Byte as a long.
*java.lang.Byte.parseByte(String)*
public static byte parseByte(java.lang.String s)
throws |java.lang.NumberFormatException|
Parses the string argument as a signed decimal byte. The characters in the
string must all be decimal digits, except that the first character may be an
ASCII minus sign '-' ('u002D') to indicate a negative value. The resulting byte
value is returned, exactly as if the argument and the radix 10 were given as
arguments to the (|java.lang.Byte|) method.
s - a String containing the byte representation to be parsed
Returns: the byte value represented by the argument in decimal
*java.lang.Byte.parseByte(String,int)*
public static byte parseByte(
java.lang.String s,
int radix)
throws |java.lang.NumberFormatException|
Parses the string argument as a signed byte in the radix specified by the
second argument. The characters in the string must all be digits, of the
specified radix (as determined by whether (|java.lang.Character|) returns a
nonnegative value) except that the first character may be an ASCII minus sign
'-' ('u002D') to indicate a negative value. The resulting byte value is
returned.
An exception of type NumberFormatException is thrown if any of the following
situations occurs:
The first argument is null or is a string of length zero.
The radix is either smaller than (|java.lang.Character|) or larger than
(|java.lang.Character|) .
Any character of the string is not a digit of the specified radix, except that
the first character may be a minus sign '-' ('u002D') provided that the string
is longer than length 1.
The value represented by the string is not a value of type byte.
s - the String containing the byte representation to be parsed
radix - the radix to be used while parsing s
Returns: the byte value represented by the string argument in the specified radix
*java.lang.Byte.shortValue()*
public short shortValue()
Returns the value of this Byte as a short.
*java.lang.Byte.toString()*
public |java.lang.String| toString()
Returns a String object representing this Byte's value. The value is converted
to signed decimal representation and returned as a string, exactly as if the
byte value were given as an argument to the (|java.lang.Byte|) method.
Returns: a string representation of the value of this object in base10.
*java.lang.Byte.toString(byte)*
public static |java.lang.String| toString(byte b)
Returns a new String object representing the specified byte. The radix is
assumed to be 10.
b - the byte to be converted
Returns: the string representation of the specified byte
*java.lang.Byte.valueOf(byte)*
public static |java.lang.Byte| valueOf(byte b)
Returns a Byte instance representing the specified byte value. If a new Byte
instance is not required, this method should generally be used in preference to
the constructor (|java.lang.Byte|) , as this method is likely to yield
significantly better space and time performance by caching frequently requested
values.
b - a byte value.
Returns: a Byte instance representing b.
*java.lang.Byte.valueOf(String)*
public static |java.lang.Byte| valueOf(java.lang.String s)
throws |java.lang.NumberFormatException|
Returns a Byte object holding the value given by the specified String. The
argument is interpreted as representing a signed decimal byte, exactly as if
the argument were given to the (|java.lang.Byte|) method. The result is a Byte
object that represents the byte value specified by the string. In other words,
this method returns a Byte object equal to the value of:
new Byte(Byte.parseByte(s))
s - the string to be parsed
Returns: a Byte object holding the value represented by the string argument
*java.lang.Byte.valueOf(String,int)*
public static |java.lang.Byte| valueOf(
java.lang.String s,
int radix)
throws |java.lang.NumberFormatException|
Returns a Byte object holding the value extracted from the specified String
when parsed with the radix given by the second argument. The first argument is
interpreted as representing a signed byte in the radix specified by the second
argument, exactly as if the argument were given to the (|java.lang.Byte|)
method. The result is a Byte object that represents the byte value specified by
the string. In other words, this method returns a Byte object equal to the
value of:
new Byte(Byte.parseByte(s, radix))
s - the string to be parsed
radix - the radix to be used in interpreting s
Returns: a Byte object holding the value represented by the string argument in the
specified radix.
