integervalueof源码

❶ java parseInt和valueof的区别

区别就是一个返回的是int，一个返回的是Integer，valueOf源码如下：

*@paramsthestringtobeparsed.
*@returnan{@codeInteger}objectholdingthevalue
*.
*@
*asaninteger.
*/
publicstaticIntegervalueOf(Strings)throwsNumberFormatException{
returnInteger.valueOf(parseInt(s,10));
}

❷ integerparseint和integervalueof的区别

Integer.parseInt()区别 Integer.valueof()
new Integer.valueof()返回的是 Integer 的对象。 Integer.parseInt() 返回的是一个 int 的值。 newInteger.valueof().intValue();返回的也是一个 的值。 Integer.valueof().intValue();返回的也是一个 int 的值。 Integer.valueof()返回的是 Integer 的对象。 Integer.parseInt() 返回的是一个 int 的值。
parseInt public static int parseInt(String s, int radix) throws NumberFormatException 以第二个参数所指定基数将字符串参数分析为一个带符号的整数。除了第一个字符可以用 ASCII 的减号 '-' 来表 示一个负值外，字符串中的字符必须是指定基数的数(由 Character.digit 是否返回非负值决定)。返回作为结果的整数值。
参数： s - 包含整数的 String 。 radix - 使用的进制
返回值： 指定基数的字符串参数所表示的整数。
抛出： NumberFormatException： 若该串不包含一个可分析的整数。 parseInt public static int parseInt(String s) throws NumberFormatException 将字符串参数作为带符号十进制整数来分析。除过第一个字符为 ASCII 字符中减号 '-' 表示的负数，字符串中的 字符都必须是十进制数。 参数： 参数： s - 串。 返回值： 返回值： 十进制参数表示的整数。 抛出： 抛出： NumberFormatException 若该串不包含一个可分析的整数。 valueOf public static Integer valueOf(String s, int radix) throws NumberFormatException 返回初始化为指定 String 值的新的 Integer 对象。若该 String 不能作为 int 分析，则抛出异常。 参数： 参数： s - 待分析的字符串。 返回值： 返回值： 新创建的 Integer ，将其以指定基数初始化为字符串参数所表示的值。 抛出： 抛出： NumberFormatException 若 String 不包含可分析的整数。 valueOf public static Integer valueOf(String s) throws NumberFormatException 返回初始化为指定 String 值的新的 Integer 对象。若该 String 不能作为 int 分析，则抛出异常。假设基数为 10 。 参数： 参数： s - 待分析的字符串。 返回值： 返回值： 新创建的 Integer ，将其初始化为字符串参数所表示的值。 抛出： 抛出： NumberFormatException 如果该串不包含一个可分析的整数。

❸ Integer中的问题

……LZ很有意思。
System.out,println(a=b);
这一句话中有两个bug,应该是
System.out.println(a==b);
另外这个问题确实是这样的，Integer会自动缓存[-128,127]之间的Integer对象。不过你如果这么写：
Integer a = new Integer(126);
Integer b = new Integer(126);
System.out.println(a==b);
输出false

❹ 请问这个java代码行是什么意思Integer.valueOf("876",8).toString()

876，不符合八进制。
valueOf
public static Integer valueOf(String s,
int radix)
throws NumberFormatException

返回一个 Integer 对象，该对象中保存了用第二个参数提供的基数进行解析时从指定的 String 中提取的值。将第一个参数解释为用第二个参数指定的基数表示的有符号整数，就好像将这些参数赋予parseInt(java.lang.String, int) 方法一样。结果是一个表示字符串指定的整数值的 Integer 对象。
换句话说，该方法返回一个等于以下值的 Integer 对象：
new Integer(Integer.parseInt(s, radix))

参数：
s - 要解析的字符串。
radix - 解释 s 时使用的基数。
返回：
一个 Integer 对象，它含有字符串参数（以指定的基数）所表示的数值。
抛出：
NumberFormatException - 如果 String 不包含可解析的 int。

parseInt("99", 8) 抛出 NumberFormatException

❺ Integer.valueof(String)

问题1:没有关系了,只是把String型的"1"转化为了Integer型的1

问题2:

(1)调用Integer类中的静态方法valueOf(String)
(2)valueOf方法将传入的参数String转化为int型值
(3)返回该值,如果String并不是纯粹由数字构成即无法转化为数字,则抛出NumberFormatException..

❻ Java中Integer这个类的详细描述，甚至原代码

直接帖着了，慢慢看吧
贴不全，不如自己到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³¹.
*/
public static final int MIN_VALUE = 0x80000000;

/**
* A constant holding the maximum value an <code>int</code> can
* have, 2³¹-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");

/**
* 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'
};

/**
* 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>
*
* </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) {

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));
}

/**
* Returns a string representation of the integer argument as an
* unsigned integer in base16.
* <p>
* The unsigned integer value is the argument plus 2³²
* if the argument is negative; otherwise, it is equal to the
* argument. This value is converted to a string of ASCII digits
* in hexadecimal (base16) 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 (base16).
* @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 base8.
* <p>
* The unsigned integer value is the argument plus 2³²
* if the argument is negative; otherwise, it is equal to the
* argument. This value is converted to a string of ASCII digits
* in octal (base8) 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 (base8).
* @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 base2.
* <p>
* The unsigned integer value is the argument plus 2³²
* if the argument is negative; otherwise it is equal to the
* argument. This value is converted to a string of ASCII digits
* in binary (base2) 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 (base2).
* @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));
}

final static char [] DigitTens = {
'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',
} ;

final static char [] DigitOnes = {
'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',
} ;

// 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 base10.
*/
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

❼ JAVA中包装类Integer.valueOf()的问题

问题1回答：返回的确实是包装类对象；
问题2回答：第二种的valueOf(int i)返回结果里对象的值就是i的值，而valueOf(String s)中的返回对象的值是把字符串s进行了Integer.parseInt(s)转化之后的值，也就是把s转化成int后的值；

问题3回答：可以直接打印是因为打印对象时会调用对象自身的toString()方法，而Integer的toString()方法就是直接打印int值，所以你可以直接打印该对象。
回答完毕，望采纳

❽ java提示了Unnecessary boxing 'Integer.valueOf(num.charAt(i))'

这个源码我没注意看过，应该是没有Integer.valueOf(char)这个方法，只有Integer.valueOf(String)