File	Doc	Category	Size	Date	Package
Integer.java	API Doc	phoneME MR2 API (J2ME)	20279	Wed May 02 17:59:54 BST 2007	java.lang

Integer

• java.lang.Object

Fields Summary
public static final int	MIN_VALUE The smallest value of type int. The constant value of this field is -2147483648.
public static final int	MAX_VALUE The largest value of type int. The constant value of this field is 2147483647.
static final char[]	digits All possible chars for representing a number as a String
private int	value The value of the Integer.

Constructors Summary
public Integer(int value) Constructs a newly allocated Integer object that represents the primitive int argument. param value the value to be represented by the Integer. this.value = value;

Methods Summary
public byte	byteValue() Returns the value of this Integer as a byte. return the value of this Integer as a byte. since JDK1.1 return (byte)value;
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 an Integer object that contains the same int value as this object. param obj the object to compare with. return true if the objects are the same; false otherwise. if (obj instanceof Integer) { return value == ((Integer)obj).intValue(); } return false;
public int	hashCode() Returns a hashcode for this Integer. return a hash code value for this object, equal to the primitive int value represented by this Integer object. return value;
public int	intValue() Returns the value of this Integer as an int. return the int value represented by this object. return value;
public long	longValue() Returns the value of this Integer as a long. return the int value represented by this object that is converted to type long and the result of the conversion is returned. return (long)value;
public static int	parseInt(java.lang.String s, int radix) Parses the string argument as a signed integer 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 {@link java.lang.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. The resulting integer 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 {@link java.lang.Character#MIN_RADIX} or larger than {@link java.lang.Character#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') provided that the string is longer than length 1. The integer value represented by the string is not a value of type int. Examples: parseInt("0", 10) returns 0 parseInt("473", 10) returns 473 parseInt("-0", 10) returns 0 parseInt("-FF", 16) returns -255 parseInt("1100110", 2) returns 102 parseInt("2147483647", 10) returns 2147483647 parseInt("-2147483648", 10) returns -2147483648 parseInt("2147483648", 10) throws a NumberFormatException parseInt("99", 8) throws a NumberFormatException parseInt("Kona", 10) throws a NumberFormatException parseInt("Kona", 27) returns 411787 param s the String containing the integer. param radix the radix to be used. return the integer represented by the string argument in the specified radix. exception NumberFormatException if the string does not contain a parsable integer. if (s == null) { throw new NumberFormatException( /* #ifdef VERBOSE_EXCEPTIONS */ /// skipped "null" /* #endif */ ); } if (radix < Character.MIN_RADIX) { throw new NumberFormatException( /* #ifdef VERBOSE_EXCEPTIONS */ /// skipped "radix " + radix + " less than Character.MIN_RADIX" /* #endif */ ); } if (radix > Character.MAX_RADIX) { throw new NumberFormatException( /* #ifdef VERBOSE_EXCEPTIONS */ /// skipped "radix " + radix + " greater than Character.MAX_RADIX" /* #endif */ ); } int result = 0; boolean negative = false; int i = 0, max = s.length(); int limit; int multmin; int digit; if (max > 0) { if (s.charAt(0) == '-") { negative = true; limit = Integer.MIN_VALUE; i++; } else { limit = -Integer.MAX_VALUE; } multmin = limit / radix; if (i < max) { digit = Character.digit(s.charAt(i++),radix); if (digit < 0) { throw new NumberFormatException( /* #ifdef VERBOSE_EXCEPTIONS */ /// skipped s /* #endif */ ); } else { result = -digit; } } while (i < max) { // Accumulating negatively avoids surprises near MAX_VALUE digit = Character.digit(s.charAt(i++),radix); if (digit < 0) { throw new NumberFormatException( /* #ifdef VERBOSE_EXCEPTIONS */ /// skipped s /* #endif */ ); } if (result < multmin) { throw new NumberFormatException( /* #ifdef VERBOSE_EXCEPTIONS */ /// skipped s /* #endif */ ); } result *= radix; if (result < limit + digit) { throw new NumberFormatException( /* #ifdef VERBOSE_EXCEPTIONS */ /// skipped s /* #endif */ ); } result -= digit; } } else { throw new NumberFormatException( /* #ifdef VERBOSE_EXCEPTIONS */ /// skipped s /* #endif */ ); } if (negative) { if (i > 1) { return result; } else { /* Only got "-" */ throw new NumberFormatException( /* #ifdef VERBOSE_EXCEPTIONS */ /// skipped s /* #endif */ ); } } else { return -result; }
public static int	parseInt(java.lang.String s) Parses the string argument as a signed decimal integer. 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 integer value is returned, exactly as if the argument and the radix 10 were given as arguments to the {@link #parseInt(java.lang.String, int)} method. param s a string. return the integer represented by the argument in decimal. exception NumberFormatException if the string does not contain a parsable integer. return parseInt(s,10);
public short	shortValue() Returns the value of this Integer as a short. return the value of this Integer as a short. since JDK1.1 return (short)value;
public static java.lang.String	toBinaryString(int i) Creates a string representation of the integer argument as an unsigned integer in base 2. The unsigned integer value is the argument plus 232if the argument is negative; otherwise it is equal to the argument. This value is converted to a string of ASCII digits in binary (base 2) with no extra leading 0s. If the unsigned magnitude is zero, it is represented by a single zero character '0' ('\u0030'); otherwise, the first character of the representation of the unsigned magnitude will not be the zero character. The characters '0' ('\u0030') and '1' ('\u0031') are used as binary digits. param i an integer. return the string representation of the unsigned integer value represented by the argument in binary (base 2). since JDK1.0.2 return toUnsignedString(i, 1);
public static java.lang.String	toHexString(int i) Creates a string representation of the integer argument as an unsigned integer in base 16. The unsigned integer value is the argument plus 232 if the argument is negative; otherwise, it is equal to the argument. This value is converted to a string of ASCII digits in hexadecimal (base 16) with no extra leading 0s. If the unsigned magnitude is zero, it is represented by a single zero character '0' ('\u0030'); otherwise, the first character of the representation of the unsigned magnitude will not be the zero character. The following characters are used as hexadecimal digits: 0123456789abcdef These are the characters '\u0030' through '\u0039' and 'u\0039' through '\u0066'. param i an integer. return the string representation of the unsigned integer value represented by the argument in hexadecimal (base 16). since JDK1.0.2 return toUnsignedString(i, 4);
public static java.lang.String	toOctalString(int i) Creates a string representation of the integer argument as an unsigned integer in base 8. The unsigned integer value is the argument plus 232 if the argument is negative; otherwise, it is equal to the argument. This value is converted to a string of ASCII digits in octal (base 8) with no extra leading 0s. If the unsigned magnitude is zero, it is represented by a single zero character '0' ('\u0030'); otherwise, the first character of the representation of the unsigned magnitude will not be the zero character. The octal digits are: 01234567 These are the characters '\u0030' through '\u0037'. param i an integer return the string representation of the unsigned integer value represented by the argument in octal (base 8). since JDK1.0.2 return toUnsignedString(i, 3);
public static java.lang.String	toString(int i, int radix) Creates a string representation of the first argument in the radix specified by the second argument. If the radix is smaller than Character.MIN_RADIX or larger than Character.MAX_RADIX, then the radix 10 is used instead. If the first argument is negative, the first element of the result is the ASCII minus character '-' ('\u002d'). If the first argument is not negative, no sign character appears in the result. The remaining characters of the result represent the magnitude of the first argument. If the magnitude is zero, it is represented by a single zero character '0' ('\u0030'); otherwise, the first character of the representation of the magnitude will not be the zero character. The following ASCII characters are used as digits: 0123456789abcdefghijklmnopqrstuvwxyz These are '\u0030' through '\u0039' and '\u0061' through '\u007a'. If the radix is N, then the first N of these characters are used as radix-N digits in the order shown. Thus, the digits for hexadecimal (radix 16) are 0123456789abcdef. param i an integer. param radix the radix. return a string representation of the argument in the specified radix. see java.lang.Character#MAX_RADIX see java.lang.Character#MIN_RADIX if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) radix = 10; char buf[] = new char[33]; boolean negative = (i < 0); int charPos = 32; if (!negative) { i = -i; } while (i <= -radix) { buf[charPos--] = digits[-(i % radix)]; i = i / radix; } buf[charPos] = digits[-i]; if (negative) { buf[--charPos] = '-"; } return new String(buf, charPos, (33 - charPos));
public java.lang.String	toString() Returns a String object representing this Integer's value. The value is converted to signed decimal representation and returned as a string, exactly as if the integer value were given as an argument to the {@link java.lang.Integer#toString(int)} method. return a string representation of the value of this object in base 10. return String.valueOf(value);
public static java.lang.String	toString(int i) Returns a new String object representing the specified integer. The argument is converted to signed decimal representation and returned as a string, exactly as if the argument and radix 10 were given as arguments to the {@link #toString(int, int)} method. param i an integer to be converted. return a string representation of the argument in base 10. return toString(i, 10);
private static java.lang.String	toUnsignedString(int i, int shift) Convert the integer to an unsigned number. char[] buf = new char[32]; int charPos = 32; int radix = 1 << shift; int mask = radix - 1; do { buf[--charPos] = digits[i & mask]; i >>>= shift; } while (i != 0); return new String(buf, charPos, (32 - charPos));
public static java.lang.Integer	valueOf(java.lang.String s) Returns a new Integer object initialized to the value of the specified String. The argument is interpreted as representing a signed decimal integer, exactly as if the argument were given to the {@link #parseInt(java.lang.String)} method. The result is an Integer object that represents the integer value specified by the string. In other words, this method returns an Integer object equal to the value of: new Integer(Integer.parseInt(s)) param s the string to be parsed. return a newly constructed Integer initialized to the value represented by the string argument. exception NumberFormatException if the string cannot be parsed as an integer. return new Integer(parseInt(s, 10));
public static java.lang.Integer	valueOf(java.lang.String s, int radix) Returns a new Integer object initialized to the value of the specified String. The first argument is interpreted as representing a signed integer in the radix specified by the second argument, exactly as if the arguments were given to the {@link #parseInt(java.lang.String, int)} method. The result is an Integer object that represents the integer value specified by the string. In other words, this method returns an Integer object equal to the value of: new Integer(Integer.parseInt(s, radix)) param s the string to be parsed. param radix the radix of the integer represented by string s return a newly constructed Integer initialized to the value represented by the string argument in the specified radix. exception NumberFormatException if the String cannot be parsed as an int. return new Integer(parseInt(s,radix));