/**     * Returns an <code>Integer</code> object holding the     * value of the specified <code>String</code>. 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     * <code>Integer</code> object that represents the integer value     * specified by the string.     * <p>     * In other words, this method returns an <code>Integer</code>     * object equal to the value of:     *     * <blockquote><code>     * new Integer(Integer.parseInt(s))     * </code></blockquote>     *     * @param      s   the string to be parsed.     * @return     an <code>Integer</code> object holding 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));    }

    /**     * 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 <code>‘-‘</code> (<code>‘&#92;u002D‘</code>) to      * indicate a negative value. The resulting integer value is returned.      * <p>     * An exception of type <code>NumberFormatException</code> is     * thrown if any of the following situations occurs:     * <ul>     * <li>The first argument is <code>null</code> or is a string of     * length zero.     * <li>The radix is either smaller than      * {@link java.lang.Character#MIN_RADIX} or     * larger than {@link java.lang.Character#MAX_RADIX}.      * <li>Any character of the string is not a digit of the specified     * radix, except that the first character may be a minus sign     * <code>‘-‘</code> (<code>‘&#92;u002D‘</code>) provided that the     * string is longer than length 1.     * <li>The value represented by the string is not a value of type     * <code>int</code>.      * </ul><p>     * Examples:     * <blockquote><pre>     * 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     * </pre></blockquote>     *     * @param      s   the <code>String</code> containing the integer      *             representation to be parsed     * @param      radix   the radix to be used while parsing <code>s</code>.     * @return     the integer represented by the string argument in the     *             specified radix.     * @exception  NumberFormatException if the <code>String</code>     *            does not contain a parsable <code>int</code>.     */    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 NumberFormatException.forInputString(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 NumberFormatException.forInputString(s);        }        if (result < multmin) {            throw NumberFormatException.forInputString(s);        }        result *= radix;        if (result < limit + digit) {            throw NumberFormatException.forInputString(s);        }        result -= digit;        }    } else {        throw NumberFormatException.forInputString(s);    }    if (negative) {        if (i > 1) {        return result;        } else {    /* Only got "-" */        throw NumberFormatException.forInputString(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 <code>‘-‘</code>      * (<code>‘&#92;u002D‘</code>) 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 <code>String</code> containing the <code>int</code>     *             representation to be parsed     * @return     the integer value 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);    }