parseInt(String s)与valueOf(int i)

parseInt(String s)与valueOf(int i) 的区别

当我们需要将一个字符串转换成整型时可能会使用以下的方法：

 

String str = "12345";
int one = Integer.parseInt(str);
int two = Integer.valueOf(str);

 

使用parseInt（）和valueOf()有何区别?我们来看JDK对这两个方法的解析：

1.

public static int parseInt(String s)
                    throws NumberFormatException

将字符串参数作为有符号的十进制整数进行分析。除了第一个字符可以是用来表示负值的 ASCII 减号 '-' ( '\u002D') 外，字符串中的字符都必须是十进制数字。返回得到的整数值，就好像将该参数和基数 10 作为参数赋予 parseInt(java.lang.String, int) 方法一样。

 

参数：

s - 包含要分析的 int 表示形式的 String。

返回：

用十进制参数表示的整数值。

抛出：

NumberFormatException - 如果字符串不包含可分析的整数。

 

2.

public static Integer valueOf(String s)
                       throws NumberFormatException

返回保持指定的 String 的值的 Integer 对象。将该参数解释为表示一个有符号的十进制整数, 就好像将该参数赋予 parseInt(java.lang.String) 方法一样。结果是一个表示字符串指定的整数值的 Integer 对象。

换句话说，该方法返回一个等于以下值的 Integer 对象：

new Integer(Integer.parseInt(s))

 

参数：

s - 要解析的字符串。

返回：

保持字符串参数表示的值的 Integer 对象。

抛出：

NumberFormatException - 如果字符串不能分析为一个整数。

3.

public static Integer valueOf(int i)

返回一个表示指定的 int 值的 Integer 实例。如果不需要新的 Integer 实例，则通常应优先使用该方法，而不是构造方法 Integer(int)，因为该方法有可能通过缓存经常请求的值而显著提高空间和时间性能。

 

参数：

i - 一个 int 值。

返回：

表示 i 的 Integer 实例。

从以下版本开始：

1.5

   4.简单地说就是：

 

static int parseInt(String s):       将字符串参数作为有符号的十进制整数进行分析，返回一个int值。

static Integer valueOf(int i) :      返回一个表示指定的 int 值的 Integer 实例。

static Integer valueOf(String s) :      返回保持指定的 String 的值的 Integer 对象（实例）。

    从返回值可以看出它们的区别 : parseInt()返回的是基本类型int， 而valueOf()返回的是包装类Integer。Integer可以使用对象方法， 而int类型不能和Object类型进行互相转换。

 

  既然 static Integer valueOf(String s)返回的是一个Integer对象，却可以像这样用：

   

   int i = Integer.valueOf("2012"); 因为JDK1.5后的自动装箱和拆箱操作使用Integer和int可以自动转换,就像Integer i = 5;   int j  = i;一样在编译时是没有错误的

 

 

  5.从JDK的解析中我们能发现一个问题：

   当使用parseInt(String str)方法时如果字符串str中的字符有某一个不是十进制的数字时就会抛出NumberFormatException异常，例如对身份证号码310115199012242586X使用parseInt(String str)进行转换时就会抛出NumberFormatException ，解决的方法就是改用Integer.valueOf(String str)方法(现在好像也不行了，未测试过),因为Integer.valueOf(String str)方法返回的是一个保持字符串参数表示的值的 Integer 对象， Integer.parseInt(String str)返回一个基本类型。但是Integer.valueOf(String str)方法对完全非数字的字符串也是无能为力的，例如使用Integer.valueOf(String str)方法对 str = "abc"进行转换进就直接报NumberFormatException 异常。

 

 

   可以看下面的例子：

 

 

设有下面两个赋值语句：
a = Integer.parseInt(“123”);
b = Integer.valueOf(“123”).intValue();
下述说法正确的是（  d  ）。
A、a是整数类型变量，b是整数类对象。
B、a是整数类对象，b是整数类型变量。
C、a和b都是整数类对象并且值相等。 
D、a和b都是整数类型变量并且值相等。

详细解析：
parseInt(String s )方法是类Integer的静态方法，它的作用就是将形参 s 转化为整数，比如：
Interger.parseInt("1")=1;
Integer.parseInt("20")=20;
Integer.parseInt("324")=324;
当然，s 表示的整数必须合法，不然是会抛异常的。
valueOf(String s )也是Integer类的静态方法，它的作用是将形参 s 转化为Integer对象，Integer对象就是基本数据类型int型包装类，就是将int包装成一个类，这样在很多场合下是必须的。Interger.valueOf("123")=Integer(123)这时候Integer（123）就是整数123的对象表示形式，它再调用intValue()方法，就是将123的对象表示形式转化为int基本数据123，所以，选择D

 

 

6.关于整型的比较还有特别要说明的地方：

  首先，定义一个整型的方式有：

  （1）  int i = 10;

   (2)    Integer j =  new Integer(10);

   (3)    Integer k = Integer.valueOf(10);  

 

  我们来比较以下的结果：

　　　Integer a=Integer.valueOf(127);   
        Integer b=Integer.valueOf(127);   
  
        Integer aa=Integer.valueOf(128);   
        Integer bb=Integer.valueOf(128);   
    
  
　　  Integer c= 127;   
        Integer d=127;            
     
  
　　  Integer cc= 128;   
        Integer dd=128;   
           
　　 Integer e= new Integer(234);   
        Integer  f=new Integer(234);   
           
           
        System.out.println("(a==b) ? "+(a==b));   
        System.out.println("(c==d) ? "+(c==d));   
        System.out.println("(aa==bb) ? "+(aa==bb));   
        System.out.println("(cc==dd) ? "+(cc==dd));   
        System.out.println("(e==f) ? "+(e==f));              
        //输出结果如下 ：   
      //      (a==b) ? true   
        //      (c==d) ? true  
        //      (aa==bb) ? false   
        //      (cc==dd) ? false   
        //      (e==f) ? false  

 

解析如下：

 

   

（1）new产生的Integer对象

new声明的就是要生成一个新的对象，这是两个对象，地址肯定不等，比较结果为false。

 

（2）int i=10与使用valueOf()方法的效果是相同的，我们来看JDK中关于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);
 } 

  这段代码的意思已经很明了了，如果是-128到127之间的int类型转换为Integer对象，则直接从cache数组中获得，那 cache数组里是什么东西，代码如下：

 

  static final Integer cache[] = new Integer[-(-128) + 127 + 1]; 
  static {  
     for(int i = 0; i < cache.length; i++)
      cache[i] = new Integer(i - 128);
   } 

 

  cache是IntegerCache内部类的一个静态数组，容纳的是﹣128到127之间的Integer对象。通过valueOf产生包装对象时，如果int参数在﹣128和127之间，则直接从整型池中获得对象，不在该范围的int类型则通过new生成包装对象。

 

  127的包装对象是直接从整型池中获得的，不管你输入多少次127这个数字，获得的对象都是同一个，那地址当然都是相等的。而128、555超出了整型池范围，是通过new产生一个新的对象，地址不同，当然也就不相等了。

 

 

参考：

  1.http://book.51cto.com/art/201202/317488.htm

  2.http://xinxinyin666.i.sohu.com/blog/view/217519911.htm