Class Byte
- java.lang.Object
-
- java.lang.Number
-
- java.lang.Byte
- All Implemented Interfaces:
-
Serializable
,Comparable<Byte>
public final class Byte extends Number implements Comparable<Byte>
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
.
- Since:
- 1.1
- See Also:
-
Number
, Serialized Form
Field Summary
Modifier and Type | Field | Description |
---|---|---|
static int | BYTES | The number of bytes used to represent a |
static byte | MAX_VALUE | A constant holding the maximum value a |
static byte | MIN_VALUE | A constant holding the minimum value a |
static int | SIZE | The number of bits used to represent a |
static Class<Byte> | TYPE | The |
Constructor Summary
Constructor | Description |
---|---|
Byte(byte value) | Deprecated. It is rarely appropriate to use this constructor. |
Byte(String s) | Deprecated. It is rarely appropriate to use this constructor. |
Method Summary
Modifier and Type | Method | Description |
---|---|---|
byte | byteValue() | Returns the value of this |
static int | compare(byte x,
byte y) | Compares two |
int | compareTo(Byte anotherByte) | Compares two |
static int | compareUnsigned(byte x,
byte y) | Compares two |
static Byte | decode(String nm) | Decodes a |
double | doubleValue() | Returns the value of this |
boolean | equals(Object obj) | Compares this object to the specified object. |
float | floatValue() | Returns the value of this |
int | hashCode() | Returns a hash code for this |
static int | hashCode(byte value) | Returns a hash code for a |
int | intValue() | Returns the value of this |
long | longValue() | Returns the value of this |
static byte | parseByte(String s) | Parses the string argument as a signed decimal |
static byte | parseByte(String s,
int radix) | Parses the string argument as a signed |
short | shortValue() | Returns the value of this |
String | toString() | Returns a |
static String | toString(byte b) | Returns a new |
static int | toUnsignedInt(byte x) | Converts the argument to an |
static long | toUnsignedLong(byte x) | Converts the argument to a |
static Byte | valueOf(byte b) | Returns a |
static Byte | valueOf(String s) | Returns a |
static Byte | valueOf(String s,
int radix) | Returns a |
Methods declared in class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait
Field Detail
MIN_VALUE
public static final byte MIN_VALUE
A constant holding the minimum value a byte
can have, -27.
- See Also:
- Constant Field Values
MAX_VALUE
public static final byte MAX_VALUE
A constant holding the maximum value a byte
can have, 27-1.
- See Also:
- Constant Field Values
TYPE
public static final Class<Byte> TYPE
The Class
instance representing the primitive type byte
.
SIZE
public static final int SIZE
The number of bits used to represent a byte
value in two's complement binary form.
- Since:
- 1.5
- See Also:
- Constant Field Values
BYTES
public static final int BYTES
The number of bytes used to represent a byte
value in two's complement binary form.
- Since:
- 1.8
- See Also:
- Constant Field Values
Constructor Detail
Byte
@Deprecated(since="9") public Byte(byte value)
valueOf(byte)
is generally a better choice, as it is likely to yield significantly better space and time performance.Constructs a newly allocated Byte
object that represents the specified byte
value.
- Parameters:
-
value
- the value to be represented by theByte
.
Byte
@Deprecated(since="9") public Byte(String s) throws NumberFormatException
parseByte(String)
to convert a string to a byte
primitive, or use valueOf(String)
to convert a string to a Byte
object.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.
- Parameters:
-
s
- theString
to be converted to aByte
- Throws:
-
NumberFormatException
- if theString
does not contain a parsablebyte
.
Method Detail
toString
public static String toString(byte b)
Returns a new String
object representing the specified byte
. The radix is assumed to be 10.
- Parameters:
-
b
- thebyte
to be converted - Returns:
- the string representation of the specified
byte
- See Also:
Integer.toString(int)
valueOf
public static 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 Byte(byte)
, as this method is likely to yield significantly better space and time performance since all byte values are cached.
- Parameters:
-
b
- a byte value. - Returns:
- a
Byte
instance representingb
. - Since:
- 1.5
parseByte
public static byte parseByte(String s, int radix) throws 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 Character.digit(char,
int)
returns a nonnegative value) except that the first character may be an ASCII minus sign '-'
('\u002D'
) to indicate a negative value or an ASCII plus sign '+'
('\u002B'
) to indicate a positive 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
Character.MIN_RADIX
or larger thanCharacter.MAX_RADIX
. - Any character of the string is not a digit of the specified radix, except that the first character may be a minus sign
'-'
('\u002D'
) or plus sign'+'
('\u002B'
) provided that the string is longer than length 1. - The value represented by the string is not a value of type
byte
.
- Parameters:
-
s
- theString
containing thebyte
representation to be parsed -
radix
- the radix to be used while parsings
- Returns:
- the
byte
value represented by the string argument in the specified radix - Throws:
-
NumberFormatException
- If the string does not contain a parsablebyte
.
parseByte
public static byte parseByte(String s) throws 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 or an ASCII plus sign '+'
('\u002B'
) to indicate a positive value. The resulting byte
value is returned, exactly as if the argument and the radix 10 were given as arguments to the parseByte(java.lang.String, int)
method.
- Parameters:
-
s
- aString
containing thebyte
representation to be parsed - Returns:
- the
byte
value represented by the argument in decimal - Throws:
-
NumberFormatException
- if the string does not contain a parsablebyte
.
valueOf
public static Byte valueOf(String s, int radix) throws 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 parseByte(java.lang.String,
int)
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))
- Parameters:
-
s
- the string to be parsed -
radix
- the radix to be used in interpretings
- Returns:
- a
Byte
object holding the value represented by the string argument in the specified radix. - Throws:
-
NumberFormatException
- If theString
does not contain a parsablebyte
.
valueOf
public static Byte valueOf(String s) throws 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 parseByte(java.lang.String)
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))
- Parameters:
-
s
- the string to be parsed - Returns:
- a
Byte
object holding the value represented by the string argument - Throws:
-
NumberFormatException
- If theString
does not contain a parsablebyte
.
decode
public static Byte decode(String nm) throws 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 - Signopt
- Sign:
-
-
+
The sequence of characters following an optional 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 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
.
- Parameters:
-
nm
- theString
to decode. - Returns:
- a
Byte
object holding thebyte
value represented bynm
- Throws:
-
NumberFormatException
- if theString
does not contain a parsablebyte
. - See Also:
parseByte(java.lang.String, int)
byteValue
public byte byteValue()
Returns the value of this Byte
as a byte
.
- Overrides:
-
byteValue
in classNumber
- Returns:
- the numeric value represented by this object after conversion to type
byte
.
shortValue
public short shortValue()
Returns the value of this Byte
as a short
after a widening primitive conversion.
- Overrides:
-
shortValue
in classNumber
- Returns:
- the numeric value represented by this object after conversion to type
short
.
intValue
public int intValue()
Returns the value of this Byte
as an int
after a widening primitive conversion.
- Specified by:
-
intValue
in classNumber
- Returns:
- the numeric value represented by this object after conversion to type
int
.
longValue
public long longValue()
Returns the value of this Byte
as a long
after a widening primitive conversion.
- Specified by:
-
longValue
in classNumber
- Returns:
- the numeric value represented by this object after conversion to type
long
.
floatValue
public float floatValue()
Returns the value of this Byte
as a float
after a widening primitive conversion.
- Specified by:
-
floatValue
in classNumber
- Returns:
- the numeric value represented by this object after conversion to type
float
.
doubleValue
public double doubleValue()
Returns the value of this Byte
as a double
after a widening primitive conversion.
- Specified by:
-
doubleValue
in classNumber
- Returns:
- the numeric value represented by this object after conversion to type
double
.
toString
public 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 toString(byte)
method.
- Overrides:
-
toString
in classObject
- Returns:
- a string representation of the value of this object in base 10.
hashCode
public int hashCode()
Returns a hash code for this Byte
; equal to the result of invoking intValue()
.
- Overrides:
-
hashCode
in classObject
- Returns:
- a hash code value for this
Byte
- See Also:
-
Object.equals(java.lang.Object)
,System.identityHashCode(java.lang.Object)
hashCode
public static int hashCode(byte value)
Returns a hash code for a byte
value; compatible with Byte.hashCode()
.
- Parameters:
-
value
- the value to hash - Returns:
- a hash code value for a
byte
value. - Since:
- 1.8
equals
public boolean equals(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.
- Overrides:
-
equals
in classObject
- Parameters:
-
obj
- the object to compare with - Returns:
-
true
if the objects are the same;false
otherwise. - See Also:
-
Object.hashCode()
,HashMap
compareTo
public int compareTo(Byte anotherByte)
Compares two Byte
objects numerically.
- Specified by:
-
compareTo
in interfaceComparable<Byte>
- Parameters:
-
anotherByte
- theByte
to be compared. - Returns:
- the value
0
if thisByte
is equal to the argumentByte
; a value less than0
if thisByte
is numerically less than the argumentByte
; and a value greater than0
if thisByte
is numerically greater than the argumentByte
(signed comparison). - Since:
- 1.2
compare
public static int compare(byte x, byte y)
Compares two byte
values numerically. The value returned is identical to what would be returned by:
Byte.valueOf(x).compareTo(Byte.valueOf(y))
- Parameters:
-
x
- the firstbyte
to compare -
y
- the secondbyte
to compare - Returns:
- the value
0
ifx == y
; a value less than0
ifx < y
; and a value greater than0
ifx > y
- Since:
- 1.7
compareUnsigned
public static int compareUnsigned(byte x, byte y)
Compares two byte
values numerically treating the values as unsigned.
- Parameters:
-
x
- the firstbyte
to compare -
y
- the secondbyte
to compare - Returns:
- the value
0
ifx == y
; a value less than0
ifx < y
as unsigned values; and a value greater than0
ifx > y
as unsigned values - Since:
- 9
toUnsignedInt
public static int toUnsignedInt(byte x)
Converts the argument to an int
by an unsigned conversion. In an unsigned conversion to an int
, the high-order 24 bits of the int
are zero and the low-order 8 bits are equal to the bits of the byte
argument. Consequently, zero and positive byte
values are mapped to a numerically equal int
value and negative
byte
values are mapped to an int
value equal to the input plus 28.
- Parameters:
-
x
- the value to convert to an unsignedint
- Returns:
- the argument converted to
int
by an unsigned conversion - Since:
- 1.8
toUnsignedLong
public static long toUnsignedLong(byte x)
Converts the argument to a long
by an unsigned conversion. In an unsigned conversion to a long
, the high-order 56 bits of the long
are zero and the low-order 8 bits are equal to the bits of the byte
argument. Consequently, zero and positive byte
values are mapped to a numerically equal long
value and negative
byte
values are mapped to a long
value equal to the input plus 28.
- Parameters:
-
x
- the value to convert to an unsignedlong
- Returns:
- the argument converted to
long
by an unsigned conversion - Since:
- 1.8