Short represent primitive
* short values.
*
* Additionally, this class provides various helper functions and variables
* related to shorts.
*
* @author Paul Fisher
* @author John Keiser
* @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 Short extends Number implements Comparableshort can represent is -32768 (or
* -215).
*/
public static final short MIN_VALUE = -32768;
/**
* The minimum value a short can represent is 32767 (or
* 215).
*/
public static final short MAX_VALUE = 32767;
/**
* The primitive type short is represented by this
* Class object.
*/
public static final Classshort.
* @since 1.5
*/
public static final int SIZE = 16;
// This caches some Short values, and is used by boxing conversions
// via valueOf(). We must cache at least -128..127; these constants
// control how much we actually cache.
private static final int MIN_CACHE = -128;
private static final int MAX_CACHE = 127;
private static Short[] shortCache = new Short[MAX_CACHE - MIN_CACHE + 1];
static
{
for (short i=MIN_CACHE; i <= MAX_CACHE; i++)
shortCache[i - MIN_CACHE] = new Short(i);
}
/**
* The immutable value of this Short.
*
* @serial the wrapped short
*/
private final short value;
/**
* Create a Short object representing the value of the
* short argument.
*
* @param value the value to use
*/
public Short(short value)
{
this.value = value;
}
/**
* Create a Short object representing the value of the
* argument after conversion to a short.
*
* @param s the string to convert
* @throws NumberFormatException if the String cannot be parsed
*/
public Short(String s)
{
value = parseShort(s, 10);
}
/**
* Converts the short to a String and assumes
* a radix of 10.
*
* @param s the short to convert to String
* @return the String representation of the argument
*/
public static String toString(short s)
{
return String.valueOf(s);
}
/**
* Converts the specified String into a short.
* This function assumes a radix of 10.
*
* @param s the String to convert
* @return the short value of s
* @throws NumberFormatException if s cannot be parsed as a
* short
*/
public static short parseShort(String s)
{
return parseShort(s, 10);
}
/**
* Converts the specified String into a short
* 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 short
* @throws NumberFormatException if s cannot be parsed as a
* short
*/
public static short parseShort(String s, int radix)
{
int i = Integer.parseInt(s, radix, false);
if ((short) i != i)
throw new NumberFormatException();
return (short) i;
}
/**
* Creates a new Short 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 Short
* @throws NumberFormatException if s cannot be parsed as a
* short
* @see #parseShort(String, int)
*/
public static Short valueOf(String s, int radix)
{
return valueOf(parseShort(s, radix));
}
/**
* Creates a new Short object using the String,
* assuming a radix of 10.
*
* @param s the String to convert
* @return the new Short
* @throws NumberFormatException if s cannot be parsed as a
* short
* @see #Short(String)
* @see #parseShort(String)
*/
public static Short valueOf(String s)
{
return valueOf(parseShort(s, 10));
}
/**
* Returns a Short object wrapping the value.
* In contrast to the Short constructor, this method
* will cache some values. It is used by boxing conversion.
*
* @param val the value to wrap
* @return the Short
* @since 1.5
*/
public static Short valueOf(short val)
{
if (val < MIN_CACHE || val > MAX_CACHE)
return new Short(val);
else
return shortCache[val - MIN_CACHE];
}
/**
* Convert the specified String into a Short.
* 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 { 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 Short
* @throws NumberFormatException if s cannot be parsed as a
* short
* @throws NullPointerException if s is null
* @see Integer#decode(String)
*/
public static Short decode(String s)
{
int i = Integer.parseInt(s, 10, true);
if ((short) i != i)
throw new NumberFormatException();
return valueOf((short) i);
}
/**
* Return the value of this Short as a byte.
*
* @return the byte value
*/
public byte byteValue()
{
return (byte) value;
}
/**
* Return the value of this Short.
*
* @return the short value
*/
public short shortValue()
{
return value;
}
/**
* Return the value of this Short as an int.
*
* @return the int value
*/
public int intValue()
{
return value;
}
/**
* Return the value of this Short as a long.
*
* @return the long value
*/
public long longValue()
{
return value;
}
/**
* Return the value of this Short as a float.
*
* @return the float value
*/
public float floatValue()
{
return value;
}
/**
* Return the value of this Short as a double.
*
* @return the double value
*/
public double doubleValue()
{
return value;
}
/**
* Converts the Short value to a String and
* assumes a radix of 10.
*
* @return the String representation of this Short
*/
public String toString()
{
return String.valueOf(value);
}
/**
* Return a hashcode representing this Object. Short'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
* Short and represents the same short value.
*
* @param obj the object to compare
* @return whether these Objects are semantically equal
*/
public boolean equals(Object obj)
{
return obj instanceof Short && value == ((Short) obj).value;
}
/**
* Compare two Shorts numerically by comparing their short
* values. The result is positive if the first is greater, negative if the
* second is greater, and 0 if the two are equal.
*
* @param s the Short to compare
* @return the comparison
* @since 1.2
*/
public int compareTo(Short s)
{
return value - s.value;
}
/**
* Compares two unboxed short values.
* The result is positive if the first is greater, negative if the second
* is greater, and 0 if the two are equal.
*
* @param x First value to compare.
* @param y Second value to compare.
*
* @return positive int if the first value is greater, negative if the second
* is greater, and 0 if the two are equal.
* @since 1.7
*/
public static int compare(short x, short y)
{
return Short.valueOf(x).compareTo(Short.valueOf(y));
}
/**
* Reverse the bytes in val.
* @since 1.5
*/
public static short reverseBytes(short val)
{
return (short) (((val >> 8) & 0xff) | ((val << 8) & 0xff00));
}
}