直接帖着了,慢慢看吧 贴不全,不如自己到sun去下java的原代码,都是公开的 /* * @(#)Integer.java 1.76 03/01/23 * * Copyright 2003 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */
package java.lang;
/** * The <code>Integer</code> 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.76, 01/23/03 * @since JDK1.0 */ public final class Integer extends Number implements Comparable { /** * A constant holding the minimum value an <code>int</code> can * have, -2<sup>31</sup>. */ public static final int MIN_VALUE = 0x80000000;
/** * A constant holding the maximum value an <code>int</code> can * have, 2<sup>31</sup>-1. */ public static final int MAX_VALUE = 0x7fffffff;
/** * The <code>Class</code> instance representing the primitive type * <code>int</code>. * * @since JDK1.1 */ public static final Class TYPE = Class.getPrimitiveClass("int");
/** * Returns 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> * (<code>'\u002D'</code>). If the first argument is not * negative, no sign character appears in the result. * <p> * 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 <code>'0'</code> * (<code>'\u0030'</code>); otherwise, the first character of * the representation of the magnitude will not be the zero * character. The following ASCII characters are used as digits: * <blockquote><pre> * 0123456789abcdefghijklmnopqrstuvwxyz * </pre></blockquote> * These are <code>'\u0030'</code> through * <code>'\u0039'</code> and <code>'\u0061'</code> through * <code>'\u007A'</code>. If <code>radix</code> is * <var>N</var>, then the first <var>N</var> of these characters * are used as radix-<var>N</var> digits in the order shown. Thus, * the digits for hexadecimal (radix 16) are * <code>0123456789abcdef</code>. If uppercase letters are * desired, the {@link java.lang.String#toUpperCase()} method may * be called on the result: * <blockquote><pre> * Integer.toString(n, 16).toUpperCase() * </pre></blockquote> * * @param i an integer to be converted to a string. * @param radix the radix to use in the string representation. * @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) {
/* 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)); }
/** * Returns a string representation of the integer argument as an * unsigned integer in base 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 16) with no extra leading * <code>0</code>s. If the unsigned magnitude is zero, it is * represented by a single zero character <code>'0'</code> * (<code>'\u0030'</code>); 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: * <blockquote><pre> * 0123456789abcdef * </pre></blockquote> * These are the characters <code>'\u0030'</code> through * <code>'\u0039'</code> and <code>'\u0061'</code> through * <code>'\u0066'</code>. If uppercase letters are * desired, the {@link java.lang.String#toUpperCase()} method may * be called on the result: * <blockquote><pre> * Integer.toHexString(n).toUpperCase() * </pre></blockquote> * * @param i an integer to be converted to a string. * @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); }
/** * Returns 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 8) with no extra leading <code>0</code>s. * <p> * If the unsigned magnitude is zero, it is represented by a * single zero character <code>'0'</code> * (<code>'\u0030'</code>); otherwise, the first character of * the representation of the unsigned magnitude will not be the * zero character. The following characters are used as octal * digits: * <blockquote><pre> * 01234567 * </pre></blockquote> * These are the characters <code>'\u0030'</code> through * <code>'\u0037'</code>. * * @param i an integer to be converted to a string. * @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); }
/** * Returns a string representation of the integer argument as an * unsigned integer in base 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 2) with no extra leading <code>0</code>s. * If the unsigned magnitude is zero, it is represented by a * single zero character <code>'0'</code> * (<code>'\u0030'</code>); otherwise, the first character of * the representation of the unsigned magnitude will not be the * zero character. The characters <code>'0'</code> * (<code>'\u0030'</code>) and <code>'1'</code> * (<code>'\u0031'</code>) are used as binary digits. * * @param i an integer to be converted to a string. * @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)); }
// I use the "invariant division by multiplication" trick to // accelerate Integer.toString. In particular we want to // avoid division by 10. // // The "trick" has roughly the same performance characterists // as the "classic" Integer.toString code on a non-JIT VM. // The trick avoids .rem and .div calls but has a longer code // path and is thus dominated by dispatch overhead. In the // JIT case the dispatch overhead doesn't exist and the // "trick" is considerably faster than the classic code. // // TODO-FIXME: convert (x * 52429) into the equiv shift-add // sequence. // // RE: Division by Invariant Integers using Multiplication // T Gralund, P Montgomery // ACM PLDI 1994 //
/** * Returns a <code>String</code> 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) { switch(i) { case Integer.MIN_VALUE: return "-2147483648"; case -3: return "-3"; case -2: return "-2"; case -1: return "-1"; case 0: return "0"; case 1: return "1"; case 2: return "2"; case 3: return "3"; case 4: return "4"; case 5: return "5"; case 6: return "6"; case 7: return "7"; case 8: return "8"; case 9: return "9"; case 10: return "10"; } char[] buf = (char[])(perThreadBuffer.get()); int charPos = getChars(i, buf); return new String(buf, charPos, 12 - charPos); }
// Per-thread buffer for string/stringbuffer conversion private static ThreadLocal perThreadBuffer = new ThreadLocal() { protected synchronized Object initialValue() { return new char[12]; } };
private static int getChars(int i, char[] buf) { int q, r; int charPos = 12; char sign = 0;
if (i < 0) { sign = '-'; i = -i; }
// Generate two digits per iteration while (i >= 65536) { q = i / 100; // really: r = i - (q * 100); r = i - ((q << 6) + (q << 5) + (q << 2)); i = q; buf [--charPos] = DigitOnes[r]; buf [--charPos] = DigitTens[r]; }
// Fall thru to fast mode for smaller numbers // assert(i <= 65536, i); for (;;) { q = (i * 52429) >>> (16+3); r = i - ((q << 3) + (q << 1)); // r = i-(q*10) ... buf [--charPos] = digits [r]; i = q; if (i == 0) break; } if (sign != 0) { buf [--charPos] = sign; } return charPos; }
static void appendTo(int i, StringBuffer sb) { switch(i) { case Integer.MIN_VALUE: sb.append("-2147483648"); return; case -3: sb.append("-3"); return; case -2: sb.append("-2"); return; case -1: sb.append("-1"); return; case 0: sb.append("0"); return; case 1: sb.append("1"); return; case 2: sb.append("2"); return; case 3: sb.append("3"); return; case 4: sb.append("4"); return; case 5: sb.append("5"); return; case 6: sb.append("6"); return; case 7: sb.append("7"); return; case 8: sb.append("8"); return; case 9: sb.append("9"); return; case 10: sb.append("10"); return; } char[] buf = (char[])(perThreadBuffer.get()); int charPos = getChars(i, buf); sb.append(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 {@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. * <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>'\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>'\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); }
/** * Returns an <code>Integer</code> object holding the value * extracted from the specified <code>String</code> when parsed * with the radix given by the second argument. 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 <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, radix)) * </code></blockquote> * * @param s the string to be parsed. * @param radix the radix to be u
别回头了
2024-11-06 08:55:51
public class Test { public static void main(String[] args) { Integer i1 = 127; Integer i2 = 127; Integer i3 = Integer.valueOf(127);
if (i1 == i2) System.out.println("i1 == i2 is true!"); else System.out.println("i1 == i2 is false!");
if (i1 >= i2) System.out.println("i1 >= i2 is true!"); else System.out.println("i1 >= i2 is false!");
if (i1 == i3) System.out.println("i1 == i3 is true!"); else System.out.println("i1 == i3 is false!");
} }
当值是127时,输出是: i1 == i2 is true! i1 >= i2 is true! i1 == i3 is true!
当值是128时,输出是: i1 == i2 is false! i1 >= i2 is true! i1 == i3 is false!
说明: 我使用的是Sun JDK 1.5.0_03-b07 和 Eclipse 3.2M4。
“Integer i1 = 127;”在JDK1.4下不能编译通过的,会提示:“ Type mismatch: cannot convert from int to Integer”的错误,一般改写为:“Integer i1 = new Integer(127);”。
在《JSR 201: Extending the Java Programming Language with Enumerations, Autoboxing, Enhanced for loops and Static Import》中,对这个问题,是作了这样的规定: If the value p being boxed is true, false, a byte, an ASCII character, or an integer or short number between -127 and 128, then let r1 and r2 be the results of any two boxing conversions of p. It is always the case that r1 == r2.
在Java中,The following is the list of primitives stored as immutable objects(不可变对象): * boolean values true and false * All byte values * short values between -128 and 127 * int values between -128 and 127 * char in the range \u0000 to \u007F
再看看java.lang.Integer中关于valueOf的源代码是怎样的: public static Integer valueOf(int i) { final int offset = 128; if (i >= -128 && i <= 127) { // must cache return IntegerCache.cache[i + offset]; } return new Integer(i); }