Skip to main content

NumberFormatException

java.lang.NumberFormatException

NumberFormatException is described in the javadoc comments as:

Thrown to indicate that the application has attempted to convert a string to one of the numeric types, but that the string does not have the appropriate format.
author: unascribed version: 1.20, 12/19/03 see: java.lang.Integer#toString() since: JDK1.0

Where is this exception thrown?

Following, is a list of exception messages cross-referenced to the source code responsible for throwing them. Click on the method link to view the code and see how the exception is thrown.

How is this exception thrown?

The following sub-sections identify where this exception is thrown, and how (or why) the code is throwing the exception.

Any source code quoted in this section is subject to the Java Research License unless stated otherwise.

com.sun.org.apache.xpath.internal.compiler.XPathParser.Number()

/**
   * Number ::= [0-9]+('.'[0-9]+)? | '.'[0-9]+
   *
   * @throws javax.xml.transform.TransformerException
   */
protected void Number() throws javax.xml.transform.TransformerException {
    if (null != m_token) {
        double num;
        try {
            if ((m_token.indexOf('e') > -1) || (m_token.indexOf('E') > -1)) throw new NumberFormatException();
            num = Double.valueOf(m_token).doubleValue();
        } catch (NumberFormatException nfe) {
            num = 0.0;
            error(XPATHErrorResources.ER_COULDNOT_BE_FORMATTED_TO_NUMBER, new Object[] { m_token });
        }
        m_ops.m_tokenQueue.setElementAt(new XNumber(num), m_queueMark - 1);
        m_ops.setOp(m_ops.getOp(OpMap.MAPINDEX_LENGTH), m_queueMark - 1);
        m_ops.setOp(OpMap.MAPINDEX_LENGTH, m_ops.getOp(OpMap.MAPINDEX_LENGTH) + 1);
        nextToken();
    }
}

Source: "Java SE Downloads: Java SE 6 JDK Source Code", at: http://www.oracle.com/technetwork/java/javase/downloads/index.html

com.sun.org.apache.xerces.internal.impl.dv.xs.AbstractDateTimeDV.parseInt(String, int, int)

/**
     * Given start and end position, parses string value
     * @param value  string to parse
     * @param start  Start position
     * @param end    end position
     * @return  return integer representation of characters
     */
protected int parseInt(String buffer, int start, int end) throws NumberFormatException {
    int radix = 10;
    int result = 0;
    int digit = 0;
    int limit = -Integer.MAX_VALUE;
    int multmin = limit / radix;
    int i = start;
    do {
        digit = getDigit(buffer.charAt(i));
        if (digit < 0) throw new NumberFormatException(''' + buffer.toString() + '' has wrong format');
        if (result < multmin) throw new NumberFormatException(''' + buffer.toString() + '' has wrong format');
        result *= radix;
        if (result < limit + digit) throw new NumberFormatException(''' + buffer.toString() + '' has wrong format');
        result -= digit;
    } while (++i < end);
    return -result;
}

Source: "Java SE Downloads: Java SE 6 JDK Source Code", at: http://www.oracle.com/technetwork/java/javase/downloads/index.html

com.sun.org.apache.xerces.internal.impl.dv.xs.AbstractDateTimeDV.parseIntYear(String, int)

protected int parseIntYear(String buffer, int end) {
    int radix = 10;
    int result = 0;
    boolean negative = false;
    int i = 0;
    int limit;
    int multmin;
    int digit = 0;
    if (buffer.charAt(0) == '-') {
        negative = true;
        limit = Integer.MIN_VALUE;
        i++;
    } else {
        limit = -Integer.MAX_VALUE;
    }
    multmin = limit / radix;
    while (i < end) {
        digit = getDigit(buffer.charAt(i++));
        if (digit < 0) throw new NumberFormatException(''' + buffer.toString() + '' has wrong format');
        if (result < multmin) throw new NumberFormatException(''' + buffer.toString() + '' has wrong format');
        result *= radix;
        if (result < limit + digit) throw new NumberFormatException(''' + buffer.toString() + '' has wrong format');
        result -= digit;
    }
    if (negative) {
        if (i > 1) return result; else throw new NumberFormatException(''' + buffer.toString() + '' has wrong format');
    }
    return -result;
}

Source: "Java SE Downloads: Java SE 6 JDK Source Code", at: http://www.oracle.com/technetwork/java/javase/downloads/index.html

java.math.BigInteger.parseInt(char[], int, int)

private int parseInt(char[] source, int start, int end) {
    int result = Character.digit(source[start++], 10);
    if (result == -1) throw new NumberFormatException(new String(source));
    for (int index = start; index < end; index++) {
        int nextVal = Character.digit(source[index], 10);
        if (nextVal == -1) throw new NumberFormatException(new String(source));
        result = 10 * result + nextVal;
    }
    return result;
}

Source: "Java SE Downloads: Java SE 6 JDK Source Code", at: http://www.oracle.com/technetwork/java/javase/downloads/index.html

java.lang.Package.isCompatibleWith(String)

/**
     * Compare this package's specification version with a
     * desired version. It returns true if
     * this packages specification version number is greater than or equal
     * to the desired version number. 
     * Version numbers are compared by sequentially comparing corresponding
     * components of the desired and specification strings.
     * Each component is converted as a decimal integer and the values
     * compared.
     * If the specification value is greater than the desired
     * value true is returned. If the value is less false is returned.
     * If the values are equal the period is skipped and the next pair of
     * components is compared.
     * @param desired the version string of the desired version.
     * @return true if this package's version number is greater
     *   than or equal to the desired version number
     * @exception NumberFormatException if the desired or current version
     *  is not of the correct dotted form.
     */
public boolean isCompatibleWith(String desired) throws NumberFormatException {
    if (specVersion == null || specVersion.length() < 1) {
        throw new NumberFormatException('Empty version string');
    }
    String[] sa = specVersion.split('\\.', -1);
    int[] si = new int[sa.length];
    for (int i = 0; i < sa.length; i++) {
        si[i] = Integer.parseInt(sa[i]);
        if (si[i] < 0) throw NumberFormatException.forInputString('' + si[i]);
    }
    String[] da = desired.split('\\.', -1);
    int[] di = new int[da.length];
    for (int i = 0; i < da.length; i++) {
        di[i] = Integer.parseInt(da[i]);
        if (di[i] < 0) throw NumberFormatException.forInputString('' + di[i]);
    }
    int len = Math.max(di.length, si.length);
    for (int i = 0; i < len; i++) {
        int d = (i < di.length ? di[i] : 0);
        int s = (i < si.length ? si[i] : 0);
        if (s < d) return false;
        if (s > d) return true;
    }
    return true;
}

Source: "Java SE Downloads: Java SE 6 JDK Source Code", at: http://www.oracle.com/technetwork/java/javase/downloads/index.html

com.sun.corba.se.spi.ior.iiop.GIOPVersion.parseVersion(String)

public static GIOPVersion parseVersion(String s) {
    int dotIdx = s.indexOf('.');
    if (dotIdx < 1 || dotIdx == s.length() - 1) throw new NumberFormatException('GIOP major, minor, and decimal point required: ' + s);
    int major = Integer.parseInt(s.substring(0, dotIdx));
    int minor = Integer.parseInt(s.substring(dotIdx + 1, s.length()));
    return GIOPVersion.getInstance((byte) major, (byte) minor);
}

Source: "Java SE Downloads: Java SE 6 JDK Source Code", at: http://www.oracle.com/technetwork/java/javase/downloads/index.html

java.lang.Byte.decode(String)

/**
     * Decodes a <code>String</code> into a <code>Byte</code>.
     * Accepts decimal, hexadecimal, and octal numbers given by
     * the following grammar:
     * <blockquote>
     * <dl>
     * <dt><i>DecodableString:</i>
     * <dd><i>Sign<sub>opt</sub> DecimalNumeral</i>
     * <dd><i>Sign<sub>opt</sub></i> <code>0x</code> <i>HexDigits</i>
     * <dd><i>Sign<sub>opt</sub></i> <code>0X</code> <i>HexDigits</i>
     * <dd><i>Sign<sub>opt</sub></i> <code>#</code> <i>HexDigits</i>
     * <dd><i>Sign<sub>opt</sub></i> <code>0</code> <i>OctalDigits</i>
     * <dt><i>Sign:</i>
     * <dd><code>-</code>
     * </dl>
     * </blockquote>
     * <i>DecimalNumeral</i>, <i>HexDigits</i>, and <i>OctalDigits</i>
     * are defined in <a href='http://java.sun.com/docs/books/jls/second_edition/html/lexical.doc.html#48282'>§3.10.1</a> 
     * of the <a href='http://java.sun.com/docs/books/jls/html/'>Java 
     * Language Specification</a>.
     * The sequence of characters following an (optional) negative
     * sign and/or radix specifier ("<code>0x</code>",
     * "<code>0X</code>", "<code>#</code>", or
     * leading zero) is parsed as by the <code>Byte.parseByte</code>
     * method with the indicated radix (10, 16, or 8).  This sequence
     * of characters must represent a positive value or a {@link
     * NumberFormatException} will be thrown.  The result is negated
     * if first character of the specified <code>String</code> is the
     * minus sign.  No whitespace characters are permitted in the
     * <code>String</code>.
     * @param     nm the <code>String</code> to decode.
     * @return   a <code>Byte</code> object holding the <code>byte</code>
     *   value represented by <code>nm</code>
     * @exception NumberFormatException  if the <code>String</code> does not
     *            contain a parsable <code>byte</code>.
     * @see java.lang.Byte#parseByte(java.lang.String, int)
     */
public static Byte decode(String nm) throws NumberFormatException {
    int radix = 10;
    int index = 0;
    boolean negative = false;
    Byte result;
    if (nm.startsWith('-')) {
        negative = true;
        index++;
    }
    if (nm.startsWith('0x', index) || nm.startsWith('0X', index)) {
        index += 2;
        radix = 16;
    } else if (nm.startsWith('#', index)) {
        index++;
        radix = 16;
    } else if (nm.startsWith('0', index) && nm.length() > 1 + index) {
        index++;
        radix = 8;
    }
    if (nm.startsWith('-', index)) throw new NumberFormatException('Negative sign in wrong position');
    try {
        result = Byte.valueOf(nm.substring(index), radix);
        result = negative ? new Byte((byte) -result.byteValue()) : result;
    } catch (NumberFormatException e) {
        String constant = negative ? new String('-' + nm.substring(index)) : nm.substring(index);
        result = Byte.valueOf(constant, radix);
    }
    return result;
}

Source: "Java SE Downloads: Java SE 6 JDK Source Code", at: http://www.oracle.com/technetwork/java/javase/downloads/index.html

java.lang.Integer.decode(String)

/**
     * Decodes a <code>String</code> into an <code>Integer</code>.
     * Accepts decimal, hexadecimal, and octal numbers given
     * by the following grammar:
     * <blockquote>
     * <dl>
     * <dt><i>DecodableString:</i>
     * <dd><i>Sign<sub>opt</sub> DecimalNumeral</i>
     * <dd><i>Sign<sub>opt</sub></i> <code>0x</code> <i>HexDigits</i>
     * <dd><i>Sign<sub>opt</sub></i> <code>0X</code> <i>HexDigits</i>
     * <dd><i>Sign<sub>opt</sub></i> <code>#</code> <i>HexDigits</i>
     * <dd><i>Sign<sub>opt</sub></i> <code>0</code> <i>OctalDigits</i>
     * <dt><i>Sign:</i>
     * <dd><code>-</code>
     * </dl>
     * </blockquote>
     * <i>DecimalNumeral</i>, <i>HexDigits</i>, and <i>OctalDigits</i>
     * are defined in <a href='http://java.sun.com/docs/books/jls/second_edition/html/lexical.doc.html#48282'>§3.10.1</a> 
     * of the <a href='http://java.sun.com/docs/books/jls/html/'>Java 
     * Language Specification</a>.
     * The sequence of characters following an (optional) negative
     * sign and/or radix specifier ("<code>0x</code>",
     * "<code>0X</code>", "<code>#</code>", or
     * leading zero) is parsed as by the <code>Integer.parseInt</code>
     * method with the indicated radix (10, 16, or 8).  This sequence
     * of characters must represent a positive value or a {@link
     * NumberFormatException} will be thrown.  The result is negated
     * if first character of the specified <code>String</code> is the
     * minus sign.  No whitespace characters are permitted in the
     * <code>String</code>.
     * @param     nm the <code>String</code> to decode.
     * @return    a <code>Integer</code> object holding the <code>int</code>
     *     value represented by <code>nm</code>
     * @exception NumberFormatException  if the <code>String</code> does not
     *            contain a parsable integer.
     * @see java.lang.Integer#parseInt(java.lang.String, int)
     * @since 1.2
     */
public static Integer decode(String nm) throws NumberFormatException {
    int radix = 10;
    int index = 0;
    boolean negative = false;
    Integer result;
    if (nm.startsWith('-')) {
        negative = true;
        index++;
    }
    if (nm.startsWith('0x', index) || nm.startsWith('0X', index)) {
        index += 2;
        radix = 16;
    } else if (nm.startsWith('#', index)) {
        index++;
        radix = 16;
    } else if (nm.startsWith('0', index) && nm.length() > 1 + index) {
        index++;
        radix = 8;
    }
    if (nm.startsWith('-', index)) throw new NumberFormatException('Negative sign in wrong position');
    try {
        result = Integer.valueOf(nm.substring(index), radix);
        result = negative ? new Integer(-result.intValue()) : result;
    } catch (NumberFormatException e) {
        String constant = negative ? new String('-' + nm.substring(index)) : nm.substring(index);
        result = Integer.valueOf(constant, radix);
    }
    return result;
}

Source: "Java SE Downloads: Java SE 6 JDK Source Code", at: http://www.oracle.com/technetwork/java/javase/downloads/index.html

java.lang.Long.decode(String)

/**
     * Decodes a <code>String</code> into a <code>Long</code>.
     * Accepts decimal, hexadecimal, and octal numbers given by the
     * following grammar:
     * <blockquote>
     * <dl>
     * <dt><i>DecodableString:</i>
     * <dd><i>Sign<sub>opt</sub> DecimalNumeral</i>
     * <dd><i>Sign<sub>opt</sub></i> <code>0x</code> <i>HexDigits</i>
     * <dd><i>Sign<sub>opt</sub></i> <code>0X</code> <i>HexDigits</i>
     * <dd><i>Sign<sub>opt</sub></i> <code>#</code> <i>HexDigits</i>
     * <dd><i>Sign<sub>opt</sub></i> <code>0</code> <i>OctalDigits</i>
     * <dt><i>Sign:</i>
     * <dd><code>-</code>
     * </dl>
     * </blockquote>
     * <i>DecimalNumeral</i>, <i>HexDigits</i>, and <i>OctalDigits</i>
     * are defined in <a href='http://java.sun.com/docs/books/jls/second_edition/html/lexical.doc.html#48282'>§3.10.1</a> 
     * of the <a href='http://java.sun.com/docs/books/jls/html/'>Java 
     * Language Specification</a>.
     * The sequence of characters following an (optional) negative
     * sign and/or radix specifier ("<code>0x</code>",
     * "<code>0X</code>", "<code>#</code>", or
     * leading zero) is parsed as by the <code>Long.parseLong</code>
     * method with the indicated radix (10, 16, or 8).  This sequence
     * of characters must represent a positive value or a {@link
     * NumberFormatException} will be thrown.  The result is negated
     * if first character of the specified <code>String</code> is the
     * minus sign.  No whitespace characters are permitted in the
     * <code>String</code>.
     * @param     nm the <code>String</code> to decode.
     * @return    a <code>Long</code> object holding the <code>long</code>
     *    value represented by <code>nm</code>
     * @exception NumberFormatException  if the <code>String</code> does not
     *            contain a parsable <code>long</code>.
     * @see java.lang.Long#parseLong(String, int)
     * @since 1.2
     */
public static Long decode(String nm) throws NumberFormatException {
    int radix = 10;
    int index = 0;
    boolean negative = false;
    Long result;
    if (nm.startsWith('-')) {
        negative = true;
        index++;
    }
    if (nm.startsWith('0x', index) || nm.startsWith('0X', index)) {
        index += 2;
        radix = 16;
    } else if (nm.startsWith('#', index)) {
        index++;
        radix = 16;
    } else if (nm.startsWith('0', index) && nm.length() > 1 + index) {
        index++;
        radix = 8;
    }
    if (nm.startsWith('-', index)) throw new NumberFormatException('Negative sign in wrong position');
    try {
        result = Long.valueOf(nm.substring(index), radix);
        result = negative ? new Long((long) -result.longValue()) : result;
    } catch (NumberFormatException e) {
        String constant = negative ? new String('-' + nm.substring(index)) : nm.substring(index);
        result = Long.valueOf(constant, radix);
    }
    return result;
}

Source: "Java SE Downloads: Java SE 6 JDK Source Code", at: http://www.oracle.com/technetwork/java/javase/downloads/index.html

java.lang.Short.decode(String)

/**
     * Decodes a <code>String</code> into a <code>Short</code>.
     * Accepts decimal, hexadecimal, and octal numbers given by
     * the following grammar:
     * <blockquote>
     * <dl>
     * <dt><i>DecodableString:</i>
     * <dd><i>Sign<sub>opt</sub> DecimalNumeral</i>
     * <dd><i>Sign<sub>opt</sub></i> <code>0x</code> <i>HexDigits</i>
     * <dd><i>Sign<sub>opt</sub></i> <code>0X</code> <i>HexDigits</i>
     * <dd><i>Sign<sub>opt</sub></i> <code>#</code> <i>HexDigits</i>
     * <dd><i>Sign<sub>opt</sub></i> <code>0</code> <i>OctalDigits</i>
     * <dt><i>Sign:</i>
     * <dd><code>-</code>
     * </dl>
     * </blockquote>
     * <i>DecimalNumeral</i>, <i>HexDigits</i>, and <i>OctalDigits</i>
     * are defined in <a href='http://java.sun.com/docs/books/jls/second_edition/html/lexical.doc.html#48282'>§3.10.1</a> 
     * of the <a href='http://java.sun.com/docs/books/jls/html/'>Java 
     * Language Specification</a>.
     * The sequence of characters following an (optional) negative
     * sign and/or radix specifier ("<code>0x</code>",
     * "<code>0X</code>", "<code>#</code>", or
     * leading zero) is parsed as by the <code>Short.parseShort</code>
     * method with the indicated radix (10, 16, or 8).  This sequence
     * of characters must represent a positive value or a {@link
     * NumberFormatException} will be thrown.  The result is negated
     * if first character of the specified <code>String</code> is the
     * minus sign.  No whitespace characters are permitted in the
     * <code>String</code>.
     * @param     nm the <code>String</code> to decode.
     * @return   a <code>Short</code> object holding the <code>short</code>
     *     value represented by <code>nm</code>
     * @exception NumberFormatException  if the <code>String</code> does not
     *            contain a parsable <code>short</code>.
     * @see java.lang.Short#parseShort(java.lang.String, int)
     */
public static Short decode(String nm) throws NumberFormatException {
    int radix = 10;
    int index = 0;
    boolean negative = false;
    Short result;
    if (nm.startsWith('-')) {
        negative = true;
        index++;
    }
    if (nm.startsWith('0x', index) || nm.startsWith('0X', index)) {
        index += 2;
        radix = 16;
    } else if (nm.startsWith('#', index)) {
        index++;
        radix = 16;
    } else if (nm.startsWith('0', index) && nm.length() > 1 + index) {
        index++;
        radix = 8;
    }
    if (nm.startsWith('-', index)) throw new NumberFormatException('Negative sign in wrong position');
    try {
        result = Short.valueOf(nm.substring(index), radix);
        result = negative ? new Short((short) -result.shortValue()) : result;
    } catch (NumberFormatException e) {
        String constant = negative ? new String('-' + nm.substring(index)) : nm.substring(index);
        result = Short.valueOf(constant, radix);
    }
    return result;
}

Source: "Java SE Downloads: Java SE 6 JDK Source Code", at: http://www.oracle.com/technetwork/java/javase/downloads/index.html

java.lang.Byte.parseByte(String, int)

/**
     * Parses the string argument as a signed <code>byte</code> 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>'\u002D'</code>) to indicate a negative value.  The
     * resulting <code>byte</code> value is returned.
     * 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>'\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>byte</code>.
     * </ul>
     * @param s  the <code>String</code> containing the 
     *   <code>byte</code>
     *                  representation to be parsed
     * @param radix the radix to be used while parsing <code>s</code>
     * @return   the <code>byte</code> value represented by the string 
     *                   argument in the specified radix
     * @exception NumberFormatException If the string does
     *                  not contain a parsable <code>byte</code>.
     */
public static byte parseByte(String s, int radix) throws NumberFormatException {
    int i = Integer.parseInt(s, radix);
    if (i < MIN_VALUE || i > MAX_VALUE) throw new NumberFormatException('Value out of range. Value:\'' + s + '\' Radix:' + radix);
    return (byte) i;
}

Source: "Java SE Downloads: Java SE 6 JDK Source Code", at: http://www.oracle.com/technetwork/java/javase/downloads/index.html

java.lang.Short.parseShort(String, int)

/**
     * Parses the string argument as a signed <code>short</code> 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>'\u002D'</code>) to indicate a negative value.  The
     * resulting <code>byte</code> value is returned.
     * 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>'\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>short</code>.
     * </ul>
     * @param s  the <code>String</code> containing the 
     *   <code>short</code> representation to be parsed
     * @param radix the radix to be used while parsing <code>s</code>
     * @return      the <code>short</code> represented by the string 
     *              argument in the specified radix.
     * @exception NumberFormatException If the <code>String</code> 
     *   does not contain a parsable <code>short</code>.
     */
public static short parseShort(String s, int radix) throws NumberFormatException {
    int i = Integer.parseInt(s, radix);
    if (i < MIN_VALUE || i > MAX_VALUE) throw new NumberFormatException('Value out of range. Value:\'' + s + '\' Radix:' + radix);
    return (short) i;
}

Source: "Java SE Downloads: Java SE 6 JDK Source Code", at: http://www.oracle.com/technetwork/java/javase/downloads/index.html

java.lang.Integer.parseInt(String, int)

/**
     * 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>'\u002D'</code>) to 
     * indicate a negative value. The resulting integer value is returned. 
     * 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>'\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>
     * Examples:
     * <blockquote>
     * 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
     * </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) {
            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 {
            throw NumberFormatException.forInputString(s);
        }
    } else {
        return -result;
    }
}

Source: "Java SE Downloads: Java SE 6 JDK Source Code", at: http://www.oracle.com/technetwork/java/javase/downloads/index.html

java.lang.Long.parseLong(String, int)

/**
     * Parses the string argument as a signed <code>long</code> 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>'\u002D'</code>) to
     * indicate a negative value. The resulting <code>long</code>
     * value is returned.
     * Note that neither the character <code>L</code>
     * (<code>'\u004C'</code>) nor <code>l</code>
     * (<code>'\u006C'</code>) is permitted to appear at the end
     * of the string as a type indicator, as would be permitted in
     * Java programming language source code - except that either
     * <code>L</code> or <code>l</code> may appear as a digit for a
     * radix greater than 22.
     * 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 <code>radix</code> 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>'\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>long</code>. 
     * </ul>
     * Examples:
     * <blockquote>
     * parseLong('0', 10) returns 0L
     * parseLong('473', 10) returns 473L
     * parseLong('-0', 10) returns 0L
     * parseLong('-FF', 16) returns -255L
     * parseLong('1100110', 2) returns 102L
     * parseLong('99', 8) throws a NumberFormatException
     * parseLong('Hazelnut', 10) throws a NumberFormatException
     * parseLong('Hazelnut', 36) returns 1356099454469L
     * </blockquote>
     * @param      s       the <code>String</code> containing the
     *                     <code>long</code> representation to be parsed.
     * @param      radix   the radix to be used while parsing <code>s</code>.
     * @return     the <code>long</code> represented by the string argument in
     *             the specified radix.
     * @exception  NumberFormatException  if the string does not contain a
     *               parsable <code>long</code>.
     */
public static long parseLong(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');
    }
    long result = 0;
    boolean negative = false;
    int i = 0, max = s.length();
    long limit;
    long multmin;
    int digit;
    if (max > 0) {
        if (s.charAt(0) == '-') {
            negative = true;
            limit = Long.MIN_VALUE;
            i++;
        } else {
            limit = -Long.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) {
            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 {
            throw NumberFormatException.forInputString(s);
        }
    } else {
        return -result;
    }
}

Source: "Java SE Downloads: Java SE 6 JDK Source Code", at: http://www.oracle.com/technetwork/java/javase/downloads/index.html

Comments

Popular posts from this blog

Connection refused: No available router to destination

This is a simple symptom-cause-solution blog entry only. I hope these blogs will help fellow administrators.
Symptom

The following exception occurs in WebLogic server logs. Most likely to occur during WebLogic server start-up, but similar exceptions may occur at other times.
java.net.ConnectException: t3://myserver:8000: Destination unreachable; nested exception is: java.net.ConnectException: Connection refused: connect; No available router to destination] at weblogic.jndi.internal.ExceptionTranslator.toNamingException(ExceptionTranslator.java:49) at weblogic.jndi.WLInitialContextFactoryDelegate.toNamingException(WLInitialContextFactoryDelegate.java:773) at weblogic.jndi.WLInitialContextFactoryDelegate.getInitialContext(WLInitialContextFactoryDelegate.java:363) at weblogic.jndi.Environment.getContext(Environment.java:307) at weblogic.jndi.Environment.getContext(Environment.java:277)
Cause
This message (Connection refused: connect; No available router to destination) is a kind of "catch…

BAD_CERTIFICATE - A corrupt or unuseable certificate...

This is a simple symptom-cause-solution blog entry only. I hope these blogs will help fellow administrators.
Symptom
In wls_utc, when trying to test a webservice using SSL, the following error message is received: javax.net.ssl.SSLKeyException: FATAL Alert:BAD_CERTIFICATE - A corrupt or unuseable certificate was received.
If SSL debugging is enabled, the following error also appears in the logs: ExecuteThread: '4' for queue: 'weblogic.kernel.Default (self-tuning)' <1254822672320>>
verification failed because RSA key public exponent [3] is too small
Cause
The certificate encryption is of a weaker strength than expected by newer versions of Java.
Solution
Add the flag "-Dweblogic.security.SSL.allowSmallRSAExponent=true" to the server startup parameters.
References


None.

WebLogic Admin Console

WebLogic Admin Console
The WebLogic Admin Console is a web-based, user interface used to configure and control a set of WebLogic servers or clusters (i.e. a "domain"). In any logical group of WebLogic servers there must exist one admin server, which hosts the WebLogic Admin Console application and manages the associated configuration files.
WebLogic Administrators will use the Administration Console for a number of tasks, including:
Starting and stopping WebLogic servers or entire clusters.Configuring server parameters, security, database connections and deployed applications.Viewing server status, health and metrics. Note: It is not strictly necessary to use the Weblogic Admin Console to perform these tasks, as they can be scripted using WLST (the WebLogic Scripting Tool).
Accessing the Admin Console
WebLogic Admin Console Url: http://hostname:port/console.
To access the WebLogic Administration Console, assuming the admin server has been started, goto the above url. Where hostname…