integer.java

来自「《移动Agent技术》一书的所有章节源代码。」· Java 代码 · 共 686 行 · 第 1/2 页

/*
 * @(#)Integer.java	1.43 98/07/07
 *
 * Copyright 1995-1998 by Sun Microsystems, Inc.,
 * 901 San Antonio Road, Palo Alto, California, 94303, U.S.A.
 * All rights reserved.
 * 
 * This software is the confidential and proprietary information
 * of Sun Microsystems, Inc. ("Confidential Information").  You
 * shall not disclose such Confidential Information and shall use
 * it only in accordance with the terms of the license agreement
 * you entered into with Sun.
 */

package java.lang;

/**
 * The Integer class wraps a value of the primitive type <code>int</code> 
 * in an object. An object of type <code>Integer</code> contains a 
 * single field whose type is <code>int</code>. 
 * <p>
 * In addition, this class provides several methods for converting 
 * an <code>int</code> to a <code>String</code> and a 
 * <code>String</code> to an <code>int</code>, as well as other 
 * constants and methods useful when dealing with an 
 * <code>int</code>. 
 *
 * @author  Lee Boynton
 * @author  Arthur van Hoff
 * @version 1.43, 07/07/98
 * @since   JDK1.0
 */
public final
class Integer extends Number {
    /**
     * The smallest value of type <code>int</code>. 
     *
     * @since   JDK1.0
     */
    public static final int   MIN_VALUE = 0x80000000;

    /**
     * The largest value of type <code>int</code>. 
     *
     * @since   JDK1.0
     */
    public static final int   MAX_VALUE = 0x7fffffff;

    /**
     * The Class object representing the primitive type int.
     *
     * @since   JDK1.1
     */
    public static final Class	TYPE = Class.getPrimitiveClass("int");

    /**
     * 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' 
    };
    
    /**
     * Array of chars to lookup the char for the digit in the tenth's 
     * place for a two digit, base ten number.  The char can be got by 
     * using the number as the index.
     */
    private final static char[] radixTenTenths = {
	'0', '0', '0', '0', '0', '0', '0', '0', '0', '0', 
	'1', '1', '1', '1', '1', '1', '1', '1', '1', '1', 
	'2', '2', '2', '2', '2', '2', '2', '2', '2', '2', 
	'3', '3', '3', '3', '3', '3', '3', '3', '3', '3', 
	'4', '4', '4', '4', '4', '4', '4', '4', '4', '4', 
	'5', '5', '5', '5', '5', '5', '5', '5', '5', '5', 
	'6', '6', '6', '6', '6', '6', '6', '6', '6', '6', 
	'7', '7', '7', '7', '7', '7', '7', '7', '7', '7', 
	'8', '8', '8', '8', '8', '8', '8', '8', '8', '8', 
	'9', '9', '9', '9', '9', '9', '9', '9', '9', '9'
    };
    
    /**
     * Array of chars to lookup the char for the digit in the unit's 
     * place for a two digit, base ten number.  The char can be got by 
     * using the number as the index.
     */
    private final static char[] radixTenUnits = {
	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 
	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 
	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 
	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 
	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 
	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 
	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 
	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 
	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 
	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'
    };

    /**
     * Creates a string representation of the first argument in the 
     * radix specified by the second argument. 
     * <p>
     * If the radix is smaller than <code>Character.MIN_RADIX</code> or 
     * larger than <code>Character.MAX_RADIX</code>, then the radix 
     * <code>10</code> is used instead. 
     * <p>
     * If the first argument is negative, the first element of the 
     * result is the ASCII minus character <code>'-'</code>. If the first 
     * argument is not negative, no sign character appears in the result. 
     * The following ASCII characters are used as digits: 
     * <ul><code>
     *   0123456789abcdefghijklmnopqrstuvwxyz
     * </code></ul>
     *
     * @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
     * @since   JDK1.0
     */
    public static String toString(int i, int radix) {
	if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
	    radix = 10;
	
	/* Use the faster version */
	if (radix == 10) {
	    return toString(i);
	}
	
	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&nbsp;16. 
     * <p>
     * The unsigned integer value is the argument plus 2<sup>32</sup> 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&nbsp;16) with no extra leading <code>0</code>s. 
     *
     * @param   i   an integer.
     * @return  the string representation of the unsigned integer value
     *          represented by the argument in hexadecimal (base&nbsp;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. 
     * <p>
     * The unsigned integer value is the argument plus 2<sup>32</sup> 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&nbsp;8) with no extra leading <code>0</code>s. 
     *
     * @param   i   an integer
     * @return  the string representation of the unsigned integer value
     *          represented by the argument in octal (base&mnsp;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&nbsp;2. 
     * <p>
     * The unsigned integer value is the argument plus 2<sup>32</sup>if 
     * the argument is negative; otherwise it is equal to the argument. 
     * This value is converted to a string of ASCII digits in binary 
     * (base&nbsp;2) with no extra leading <code>0</code>s. 
     *
     * @param   i   an integer.
     * @return  the string representation of the unsigned integer value
     *          represented by the argument in binary (base&nbsp;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 radix
     * is assumed to be 10.
     *
     * @param   i   an integer to be converted.
     * @return  a string representation of the argument in base&nbsp;10.
     * @since   JDK1.0
     */
    public static String toString(int i) {
	/** 
	 * Performance improvements -
	 *
	 * 1) Avoid a method call and radix checks by inlining the code for 
	 *    radix = 10 in this method.
	 * 2) Use char arrays instead of StringBuffer and avoid calls to
	 *    Character.forDigit.
	 * 3) Do computations in positive space to avoid negation each time
	 *    around the loop.
	 * 4) Unroll loop by half and use a static array of chars to look-
	 *    up chars for a digit.
	 * The other option for 4) was to use a switch statement and assign 
	 * the char for the current digit.  That was a little slower than 4)
	 * with most jits. 
	 * Speed-up = (approximately) 4x on both Solaris and Win32.
	 */
	char[] buf = new char[12];
	boolean negative = (i < 0);
	int charPos = 12;
	
	if (i == Integer.MIN_VALUE) {
	    return "-2147483648";
	}
		
	if (negative) {
	    i = -i;
	}
	
	do {
	    int digit = i%100;
	    buf[--charPos] = radixTenUnits[digit];
	    buf[--charPos] = radixTenTenths[digit];
	    i = i / 100;
	} while(i != 0);
	
	if (buf[charPos] == '0') {
	    charPos++;
	}
	if (negative) {
	    buf[--charPos] = '-';
	}
		
	return new String(buf , charPos , (12 - charPos));
    }
    
    /**
     * 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 <code>Character.digit</code> returns a 
     * nonnegative value), except that the first character may be an 
     * ASCII minus sign <code>'-'</code> to indicate a negative value. 
     * The resulting integer value is returned. 
     *
     * @param      s   the <code>String</code> 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.

     * @since      JDK1.0
     */
    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) {