www.pudn.com > j2me_cldc-1_1-fcs-src-winunix.rar > Integer.java
/* * Copyright © 2003 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * */ package java.lang; /** * The Integer class wraps a value of the primitive typeint* in an object. An object of typeIntegercontains a * single field whose type isint. ** In addition, this class provides several methods for converting * an
intto aStringand a *Stringto anint, as well as other * constants and methods useful when dealing with an *int. * * @author Lee Boynton * @author Arthur van Hoff * @version 12/17/01 (CLDC 1.1) * @since JDK1.0, CLDC 1.0 */ public final class Integer { /** * The smallest value of typeint. The constant * value of this field is -2147483648. */ public static final int MIN_VALUE = 0x80000000; /** * The largest value of typeint. The constant * value of this field is 2147483647. */ public static final int MAX_VALUE = 0x7fffffff; /** * All possible chars for representing a number as a String */ final static char[] digits = { '0' , '1' , '2' , '3' , '4' , '5' , '6' , '7' , '8' , '9' , 'a' , 'b' , 'c' , 'd' , 'e' , 'f' , 'g' , 'h' , 'i' , 'j' , 'k' , 'l' , 'm' , 'n' , 'o' , 'p' , 'q' , 'r' , 's' , 't' , 'u' , 'v' , 'w' , 'x' , 'y' , 'z' }; /** * Creates a string representation of the first argument in the * radix specified by the second argument. ** If the radix is smaller than
Character.MIN_RADIXor * larger thanCharacter.MAX_RADIX, then the radix *10is 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: *
* 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 ** 0123456789abcdefghijklmnopqrstuvwxyz ** * @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 */ public static String toString(int i, int 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)); } /** * Creates a string representation of the integer argument as an * unsigned integer in base 16. ** 0123456789abcdef. ** 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: ** 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 */ public static String toHexString(int i) { return toUnsignedString(i, 4); } /** * Creates a string representation of the integer argument as an * unsigned integer in base 8. ** 0123456789abcdef ** 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: *
* 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 */ public static String toOctalString(int i) { return toUnsignedString(i, 3); } /** * Creates a string representation of the integer argument as an * unsigned integer in base 2. ** 01234567 ** 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 */ public static String toBinaryString(int i) { return toUnsignedString(i, 1); } /** * Convert the integer to an unsigned number. */ private static String toUnsignedString(int i, int shift) { 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)); } /** * 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. */ public static String toString(int i) { return toString(i, 10); } /** * 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: *
* 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
* 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.
*/
public static int parseInt(String s, int radix)
throws NumberFormatException
{
if (s == null) {
throw new NumberFormatException("null");
}
if (radix < Character.MIN_RADIX) {
throw new NumberFormatException("radix " + radix +
" less than Character.MIN_RADIX");
}
if (radix > Character.MAX_RADIX) {
throw new NumberFormatException("radix " + radix +
" greater than Character.MAX_RADIX");
}
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(s);
} 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(s);
}
if (result < multmin) {
throw new NumberFormatException(s);
}
result *= radix;
if (result < limit + digit) {
throw new NumberFormatException(s);
}
result -= digit;
}
} else {
throw new NumberFormatException(s);
}
if (negative) {
if (i > 1) {
return result;
} else { /* Only got "-" */
throw new NumberFormatException(s);
}
} else {
return -result;
}
}
/**
* 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.
*/
public static int parseInt(String s) throws NumberFormatException {
return parseInt(s,10);
}
/**
* 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))
* 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.
*/
public static Integer valueOf(String s, int radix) throws NumberFormatException {
return new Integer(parseInt(s,radix));
}
/**
* 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))
* Integer initialized to the
* value represented by the string argument.
* @exception NumberFormatException if the string cannot be parsed
* as an integer.
*/
public static Integer valueOf(String s) throws NumberFormatException
{
return new Integer(parseInt(s, 10));
}
/**
* The value of the Integer.
*
* @serial
*/
private int value;
/**
* Constructs a newly allocated Integer object that
* represents the primitive int argument.
*
* @param value the value to be represented by the Integer.
*/
public Integer(int value) {
this.value = value;
}
/**
* Returns the value of this Integer as a byte.
*
* @return the value of this Integer as a byte.
*
* @since JDK1.1
*/
public byte byteValue() {
return (byte)value;
}
/**
* Returns the value of this Integer as a short.
*
* @return the value of this Integer as a short.
*
* @since JDK1.1
*/
public short shortValue() {
return (short)value;
}
/**
* Returns the value of this Integer as an int.
*
* @return the int value represented by this object.
*/
public int intValue() {
return value;
}
/**
* 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.
*/
public long longValue() {
return (long)value;
}
/**
* Returns the value of this Integer as a float.
*
* @return the int value represented by this object is
* converted to type float and the result of the
* conversion is returned.
* @since CLDC 1.1
*/
public float floatValue() {
return (float)value;
}
/**
* Returns the value of this Integer as a double.
*
* @return the int value represented by this object is
* converted to type double and the result of the
* conversion is returned.
* @since CLDC 1.1
*/
public double doubleValue() {
return (double)value;
}
/**
* 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.
*/
public String toString() {
return String.valueOf(value);
}
/**
* 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.
*/
public int hashCode() {
return value;
}
/**
* 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.
*/
public boolean equals(Object obj) {
if (obj instanceof Integer) {
return value == ((Integer)obj).intValue();
}
return false;
}
}