| Methods Summary |
|---|
| public static int | bitCount(int i)Counts the number of 1 bits in the specified integer; this is also
referred to as population count.
i -= ((i >> 1) & 0x55555555);
i = (i & 0x33333333) + ((i >> 2) & 0x33333333);
i = (((i >> 4) + i) & 0x0F0F0F0F);
i += (i >> 8);
i += (i >> 16);
return (i & 0x0000003F);
|
| public byte | byteValue()
return (byte) value;
|
| public int | compareTo(java.lang.Integer object)Compares this object to the specified integer object to determine their
relative order.
return value > object.value ? 1 : (value < object.value ? -1 : 0);
|
| public static java.lang.Integer | decode(java.lang.String string)Parses the specified string and returns a {@code Integer} instance if the
string can be decoded into an integer value. The string may be an
optional minus sign "-" followed by a hexadecimal ("0x..." or "#..."),
octal ("0..."), or decimal ("...") representation of an integer.
int length = string.length(), i = 0;
if (length == 0) {
// BEGIN android-changed
throw new NumberFormatException("unable to parse '"+string+"' as integer");
// END android-changed
}
char firstDigit = string.charAt(i);
boolean negative = firstDigit == '-";
if (negative) {
if (length == 1) {
// BEGIN android-changed
throw new NumberFormatException("unable to parse '"+string+"' as integer");
// END android-changed
}
firstDigit = string.charAt(++i);
}
int base = 10;
if (firstDigit == '0") {
if (++i == length) {
return valueOf(0);
}
if ((firstDigit = string.charAt(i)) == 'x" || firstDigit == 'X") {
if (i == length) {
// BEGIN android-changed
throw new NumberFormatException("unable to parse '"+string+"' as integer");
// END android-changed
}
i++;
base = 16;
} else {
base = 8;
}
} else if (firstDigit == '#") {
if (i == length) {
// BEGIN android-changed
throw new NumberFormatException("unable to parse '"+string+"' as integer");
// END android-changed
}
i++;
base = 16;
}
int result = parse(string, i, base, negative);
return valueOf(result);
|
| public double | doubleValue()
return value;
|
| public boolean | equals(java.lang.Object o)Compares this instance with the specified object and indicates if they
are equal. In order to be equal, {@code o} must be an instance of
{@code Integer} and have the same integer value as this object.
return (o instanceof Integer)
&& (value == ((Integer) o).value);
|
| public float | floatValue()
return value;
|
| public static java.lang.Integer | getInteger(java.lang.String string, int defaultValue)Returns the {@code Integer} value of the system property identified by
{@code string}. Returns the specified default value if {@code string} is
{@code null} or empty, if the property can not be found or if its value
can not be parsed as an integer.
if (string == null || string.length() == 0) {
return valueOf(defaultValue);
}
String prop = System.getProperty(string);
if (prop == null) {
return valueOf(defaultValue);
}
try {
return decode(prop);
} catch (NumberFormatException ex) {
return valueOf(defaultValue);
}
|
| public static java.lang.Integer | getInteger(java.lang.String string, java.lang.Integer defaultValue)Returns the {@code Integer} value of the system property identified by
{@code string}. Returns the specified default value if {@code string} is
{@code null} or empty, if the property can not be found or if its value
can not be parsed as an integer.
if (string == null || string.length() == 0) {
return defaultValue;
}
String prop = System.getProperty(string);
if (prop == null) {
return defaultValue;
}
try {
return decode(prop);
} catch (NumberFormatException ex) {
return defaultValue;
}
|
| public static java.lang.Integer | getInteger(java.lang.String string)Returns the {@code Integer} value of the system property identified by
{@code string}. Returns {@code null} if {@code string} is {@code null}
or empty, if the property can not be found or if its value can not be
parsed as an integer.
if (string == null || string.length() == 0) {
return null;
}
String prop = System.getProperty(string);
if (prop == null) {
return null;
}
try {
return decode(prop);
} catch (NumberFormatException ex) {
return null;
}
|
| public int | hashCode()
return value;
|
| public static int | highestOneBit(int i)Determines the highest (leftmost) bit of the specified integer that is 1
and returns the bit mask value for that bit. This is also referred to as
the Most Significant 1 Bit. Returns zero if the specified integer is
zero.
i |= (i >> 1);
i |= (i >> 2);
i |= (i >> 4);
i |= (i >> 8);
i |= (i >> 16);
return (i & ~(i >>> 1));
|
| public int | intValue()Gets the primitive value of this int.
return value;
|
| public long | longValue()
return value;
|
| public static int | lowestOneBit(int i)Determines the lowest (rightmost) bit of the specified integer that is 1
and returns the bit mask value for that bit. This is also referred
to as the Least Significant 1 Bit. Returns zero if the specified integer
is zero.
return (i & (-i));
|
| public static int | numberOfLeadingZeros(int i)Determines the number of leading zeros in the specified integer prior to
the {@link #highestOneBit(int) highest one bit}.
i |= i >> 1;
i |= i >> 2;
i |= i >> 4;
i |= i >> 8;
i |= i >> 16;
return bitCount(~i);
|
| public static int | numberOfTrailingZeros(int i)Determines the number of trailing zeros in the specified integer after
the {@link #lowestOneBit(int) lowest one bit}.
return bitCount((i & -i) - 1);
|
| private static int | parse(java.lang.String string, int offset, int radix, boolean negative)
int max = Integer.MIN_VALUE / radix;
int result = 0, length = string.length();
while (offset < length) {
int digit = Character.digit(string.charAt(offset++), radix);
if (digit == -1) {
// BEGIN android-changed
throw new NumberFormatException("unable to parse '"+string+"' as integer");
// END android-changed
}
if (max > result) {
// BEGIN android-changed
throw new NumberFormatException("unable to parse '"+string+"' as integer");
// END android-changed
}
int next = result * radix - digit;
if (next > result) {
// BEGIN android-changed
throw new NumberFormatException("unable to parse '"+string+"' as integer");
// END android-changed
}
result = next;
}
if (!negative) {
result = -result;
if (result < 0) {
// BEGIN android-changed
throw new NumberFormatException("unable to parse '"+string+"' as integer");
// END android-changed
}
}
return result;
|
| public static int | parseInt(java.lang.String string)Parses the specified string as a signed decimal integer value. The ASCII
character \u002d ('-') is recognized as the minus sign.
return parseInt(string, 10);
|
| public static int | parseInt(java.lang.String string, int radix)Parses the specified string as a signed integer value using the specified
radix. The ASCII character \u002d ('-') is recognized as the minus sign.
if (string == null || radix < Character.MIN_RADIX
|| radix > Character.MAX_RADIX) {
// BEGIN android-changed
throw new NumberFormatException("unable to parse '"+string+"' as integer");
// END android-changed
}
int length = string.length(), i = 0;
if (length == 0) {
// BEGIN android-changed
throw new NumberFormatException("unable to parse '"+string+"' as integer");
// END android-changed
}
boolean negative = string.charAt(i) == '-";
if (negative && ++i == length) {
// BEGIN android-changed
throw new NumberFormatException("unable to parse '"+string+"' as integer");
// END android-changed
}
return parse(string, i, radix, negative);
|
| public static int | reverse(int i)Reverses the order of the bits of the specified integer.
// From Hacker's Delight, 7-1, Figure 7-1
i = (i & 0x55555555) << 1 | (i >> 1) & 0x55555555;
i = (i & 0x33333333) << 2 | (i >> 2) & 0x33333333;
i = (i & 0x0F0F0F0F) << 4 | (i >> 4) & 0x0F0F0F0F;
return reverseBytes(i);
|
| public static int | reverseBytes(int i)Reverses the order of the bytes of the specified integer.
int b3 = i >>> 24;
int b2 = (i >>> 8) & 0xFF00;
int b1 = (i & 0xFF00) << 8;
int b0 = i << 24;
return (b0 | b1 | b2 | b3);
|
| public static int | rotateLeft(int i, int distance)Rotates the bits of the specified integer to the left by the specified
number of bits.
if (distance == 0) {
return i;
}
/*
* According to JLS3, 15.19, the right operand of a shift is always
* implicitly masked with 0x1F, which the negation of 'distance' is
* taking advantage of.
*/
return ((i << distance) | (i >>> (-distance)));
|
| public static int | rotateRight(int i, int distance)Rotates the bits of the specified integer to the right by the specified
number of bits.
if (distance == 0) {
return i;
}
/*
* According to JLS3, 15.19, the right operand of a shift is always
* implicitly masked with 0x1F, which the negation of 'distance' is
* taking advantage of.
*/
return ((i >>> distance) | (i << (-distance)));
|
| public short | shortValue()
return (short) value;
|
| public static int | signum(int i)Returns the value of the {@code signum} function for the specified
integer.
return (i == 0 ? 0 : (i < 0 ? -1 : 1));
|
| public static java.lang.String | toBinaryString(int i)Converts the specified integer into its binary string representation. The
returned string is a concatenation of '0' and '1' characters.
int count = 1, j = i;
if (i < 0) {
count = 32;
} else {
while ((j >>>= 1) != 0) {
count++;
}
}
char[] buffer = new char[count];
do {
buffer[--count] = (char) ((i & 1) + '0");
i >>>= 1;
} while (count > 0);
return new String(0, buffer.length, buffer);
|
| public static java.lang.String | toHexString(int i)Converts the specified integer into its hexadecimal string
representation. The returned string is a concatenation of characters from
'0' to '9' and 'a' to 'f'.
int count = 1, j = i;
if (i < 0) {
count = 8;
} else {
while ((j >>>= 4) != 0) {
count++;
}
}
char[] buffer = new char[count];
do {
int t = i & 15;
if (t > 9) {
t = t - 10 + 'a";
} else {
t += '0";
}
buffer[--count] = (char) t;
i >>>= 4;
} while (count > 0);
return new String(0, buffer.length, buffer);
|
| public static java.lang.String | toOctalString(int i)Converts the specified integer into its octal string representation. The
returned string is a concatenation of characters from '0' to '7'.
int count = 1, j = i;
if (i < 0) {
count = 11;
} else {
while ((j >>>= 3) != 0) {
count++;
}
}
char[] buffer = new char[count];
do {
buffer[--count] = (char) ((i & 7) + '0");
i >>>= 3;
} while (count > 0);
return new String(0, buffer.length, buffer);
|
| public java.lang.String | toString()
return Integer.toString(value);
|
| public static java.lang.String | toString(int i)Converts the specified integer into its decimal string representation.
The returned string is a concatenation of a minus sign if the number is
negative and characters from '0' to '9'.
return toString(i, 10);
|
| public static java.lang.String | toString(int i, int radix)Converts the specified integer into a string representation based on the
specified radix. The returned string is a concatenation of a minus sign
if the number is negative and characters from '0' to '9' and 'a' to 'z',
depending on the radix. If {@code radix} is not in the interval defined
by {@code Character.MIN_RADIX} and {@code Character.MAX_RADIX} then 10 is
used as the base for the conversion.
if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) {
radix = 10;
}
if (i == 0) {
return "0"; //$NON-NLS-1$
}
int count = 2, j = i;
boolean negative = i < 0;
if (!negative) {
count = 1;
j = -i;
}
while ((i /= radix) != 0) {
count++;
}
char[] buffer = new char[count];
do {
int ch = 0 - (j % radix);
if (ch > 9) {
ch = ch - 10 + 'a";
} else {
ch += '0";
}
buffer[--count] = (char) ch;
} while ((j /= radix) != 0);
if (negative) {
buffer[0] = '-";
}
return new String(0, buffer.length, buffer);
|
| public static java.lang.Integer | valueOf(java.lang.String string)Parses the specified string as a signed decimal integer value.
return valueOf(parseInt(string));
|
| public static java.lang.Integer | valueOf(java.lang.String string, int radix)Parses the specified string as a signed integer value using the specified
radix.
return valueOf(parseInt(string, radix));
|
| public static java.lang.Integer | valueOf(int i)Returns a {@code Integer} instance for the specified integer value.
If it is not necessary to get a new {@code Integer} instance, it is
recommended to use this method instead of the constructor, since it
maintains a cache of instances which may result in better performance.
if (i < -128 || i > 127) {
return new Integer(i);
}
return valueOfCache.CACHE [i+128];
|
