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

本文详细解析了Java中将字符串转换为整型的parseInt与valueOf方法的区别,包括参数、返回值、异常处理及性能优化。还讨论了整型比较、对象创建和自动装箱拆箱的概念,并提供了实例代码进行演示。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

本文转自 for_dream的 iteye博客

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

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

 

Java代码   收藏代码
  1. String str = "12345";  
  2. int one = Integer.parseInt(str);  
  3. 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);  

 

  我们来比较以下的结果:

Java代码   收藏代码
  1. Integer a=Integer.valueOf(127);     
  2.      Integer b=Integer.valueOf(127);     
  3.   
  4.      Integer aa=Integer.valueOf(128);     
  5.      Integer bb=Integer.valueOf(128);     
  6.    
  7.   
  8.  Integer c= 127;     
  9.      Integer d=127;              
  10.     
  11.   
  12.  Integer cc= 128;     
  13.      Integer dd=128;     
  14.           
  15. Integer e= new Integer(234);     
  16.      Integer  f=new Integer(234);     
  17.           
  18.           
  19.      System.out.println("(a==b) ? "+(a==b));     
  20.      System.out.println("(c==d) ? "+(c==d));     
  21.      System.out.println("(aa==bb) ? "+(aa==bb));     
  22.      System.out.println("(cc==dd) ? "+(cc==dd));     
  23.      System.out.println("(e==f) ? "+(e==f));                
  24.      //输出结果如下 :     
  25.    //      (a==b) ? true     
  26.      //      (c==d) ? true    
  27.      //      (aa==bb) ? false     
  28.      //      (cc==dd) ? false     
  29.      //      (e==f) ? false    

 

解析如下:

 

   

(1)new产生的Integer对象

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

 

(2)int i=10与使用valueOf()方法的效果是相同的,我们来看JDK中关于Integer.valueOf的实现代码:

 

Java代码   收藏代码
  1. public static Integer valueOf(int i) {      
  2.      final int offset = 128;    
  3.      if (i >= -128 && i <= 127) {  
  4.          // must cache  
  5.           return IntegerCache.cache[i + offset];   
  6.       }  
  7.      return new Integer(i);  
  8.  }   

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

 

Java代码   收藏代码
  1. static final Integer cache[] = new Integer[-(-128) + 127 + 1];   
  2. static {    
  3.    for(int i = 0; i < cache.length; i++)  
  4.     cache[i] = new Integer(i - 128);  
  5.  }   

 

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

 

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

-----

原帖地址

http://for-dream.iteye.com/blog/1595847

<think>我们正在讨论Integer.parseInt(String)Integer.valueOf(String)区别。根据引用内容,我们可以总结如下: 1. **返回值类型不同**: - `Integer.parseInt(String s)` 返回的是基本数据类型 `int`。 - `Integer.valueOf(String s)` 返回的是包装类 `Integer` 的对象。 2. **内部实现**: - `parseInt` 方法内部调用了 `parseInt(String s, int radix)`,默认使用十进制。 - `valueOf` 方法内部调用了 `parseInt` 方法得到 `int` 值,然后使用 `Integer.valueOf(int)` 将其转换为 `Integer` 对象。 3. **缓存机制**: - `Integer.valueOf(int)` 方法会使用缓存。对于范围在 -128 到 127 之间的整数,会返回缓存中的对象,而不是新建对象。但注意,这里说的是 `valueOf(int)` 的缓存,而 `valueOf(String)` 因为内部调用了 `parseInt` 得到 `int`,再调用 `valueOf(int)`,所以同样适用缓存。 4. **参数类型**: - `parseInt` 方法只能接受 `String` 类型参数。 - `valueOf` 方法可以接受多种类型参数(如 `byte`, `char`, `short`, `int`, `long` 等),但这里我们讨论的是字符串参数。 5. **自动拆箱**: - 由于 `valueOf` 返回的是 `Integer` 对象,但在需要 `int` 的上下文中(如赋值给 `int` 变量,算术运算等),会自动拆箱为 `int`。因此,在大多数情况下,两者可以互换使用,但要注意可能发生的自动拆箱带来的性能影响(微乎其微)以及空指针风险(如果返回的 `Integer` 对象为 `null`,但这种情况在转换字符串时不会出现,因为转换失败会抛出异常)。 6. **异常处理**: - 两者在转换失败时都会抛出 `NumberFormatException`。 7. **使用场景**: - 如果需要基本类型 `int`,使用 `parseInt` 更直接,避免创建对象(但实际上,在自动拆箱下,`valueOf` 也会被优化,且缓存机制可能减少对象创建)。 - 如果需要 `Integer` 对象(例如放入集合中),使用 `valueOf` 可以避免显式创建对象。 根据引用[4]和[5]: > Integer.parseInt()返回intInteger.valueOf()返回int的封装类Integer。 > 通常情况下,如果只需要使用整数的值而不需要Integer对象,建议使用Integer.parseInt(str)方法。如果需要将整数作为对象进行操作,则可以使用Integer.valueOf(str)。 因此,我们可以这样总结: - 如果你需要一个基本类型 `int`,那么使用 `parseInt` 更合适。 - 如果你需要一个 `Integer` 对象(例如要放入集合中,或者需要使用对象的方法),那么使用 `valueOf` 更合适。 另外,引用[3]提到: > 当参数类型为String时,Integer.ParseInt(String)返回intInteger.valueOf(String)返回Integer,无区别。 这里说的“无区别”是指功能上都可以将字符串转为整数,但返回类型不同。 同时,引用[3]还提到: > 由于Integer.valueOf()的参数可以为多种类型;①当参数为byte,char,short,string等自动转换为int类型时,会自动转换,当为float或double时会提示错误。②特殊的:当参数类型为char时,Integer.valueOf()会自动计算char类型的ASII码,如对于char ch=‘a’,使用Integer.valueOf(ch)输出97. 这里需要注意,我们讨论的是参数为字符串的情况。对于其他类型,`valueOf` 有重载方法。 现在,我们按照要求组织答案,包括数学公式(如果有的话,但本题不涉及复杂公式,所以可能不需要)和代码示例。 注意:在回答中,我们需要在引用内容的末尾添加引用标识,如[^1]。</think>### Java 中 `Integer.parseInt()` `Integer.valueOf()` 的区别详解 #### 🔍 核心区别总结 | 特性 | `Integer.parseInt(String)` | `Integer.valueOf(String)` | |---------------------|----------------------------|---------------------------| | **返回值类型** | `int` (基本数据类型) | `Integer` (包装类对象) | | **内部实现** | 直接调用 `parseInt(s, 10)` | 调用 `parseInt()` 后包装为对象 | | **缓存机制** | ❌ 无缓存 | ✅ 使用整数缓存池 (-128~127) | | **参数兼容性** | 仅支持 `String` | 支持多种类型(包括 `char`) | | **内存开销** | 更低(无对象创建) | 更高(可能创建新对象) | | **推荐使用场景** | 需要基本类型计算的场景 | 需要对象操作的场景(如集合) | --- #### 💡 详细解析(含源码分析) 1. **返回值本质区别** ```java // parseInt 返回基本类型 int int num1 = Integer.parseInt("42"); // → 42 (基本类型) // valueOf 返回包装类 Integer Integer num2 = Integer.valueOf("42"); // → Integer@1234 (对象引用) ``` - **关键点**:`parseInt()` 直接返回 `int`,而 `valueOf()` 返回的是包装类对象([^4]) 2. **源码实现差异** ```java // parseInt 源码 (简化版) public static int parseInt(String s) { return parseInt(s, 10); // 直接返回 int } // valueOf 源码 (简化版) public static Integer valueOf(String s) { return Integer.valueOf(parseInt(s, 10)); // 调用 parseInt 后包装 } ``` - `valueOf()` 内部依赖 `parseInt()` 进行字符串转换([^4]) - 对于 `int` 值,`Integer.valueOf(int)` 会使用缓存池优化 3. **缓存机制对比** ```java Integer a = Integer.valueOf(127); Integer b = Integer.valueOf(127); System.out.println(a == b); // true (使用缓存池) Integer c = Integer.valueOf(128); Integer d = Integer.valueOf(128); System.out.println(c == d); // false (超出缓存范围) ``` - 缓存范围:**-128 到 127**(通过 `IntegerCache` 实现) - `parseInt()` 无此优化([^1]) 4. **参数兼容性差异** ```java // valueOf 支持多种类型 Integer ascii = Integer.valueOf('A'); // 65 (ASCII 值) // Integer.parse('A'); // 编译错误! // 处理浮点数需注意 Double.parseDouble("3.14"); // ✅ 正确方式 // Integer.valueOf(3.14); // ❌ 编译错误 ``` - `valueOf()` 可接受 `char` 类型并自动转换 ASCII([^3]) - 两者都无法直接处理浮点数字符串 --- #### ⚠️ 异常处理最佳实践 1. **统一异常类型** ```java try { int num = Integer.parseInt("12a"); // 抛出 NumberFormatException } catch (NumberFormatException e) { System.out.println("无效数字格式"); } ``` - 两者对非法输入均抛出 `NumberFormatException` 2. **性能内存建议** - 优先使用 `parseInt()` 的场景: ```java // 计算场景(避免自动拆箱开销) int sum = Integer.parseInt("100") + 50; ``` - 优先使用 `valueOf()` 的场景: ```java // 集合操作 List<Integer> list = new ArrayList<>(); list.add(Integer.valueOf("42")); ``` 3. **空值安全处理** ```java // 使用 Optional 避免 NPE String input = getInput(); int safeValue = Optional.ofNullable(input) .filter(s -> s.matches("\\d+")) .map(Integer::parseInt) .orElse(0); ``` --- #### 💎 终极选择指南 | 场景 | 推荐方法 | 原因 | |-------------------------------|------------------------|-------------------------------| | 数学运算/基本类型操作 | `Integer.parseInt()` | 避免自动拆箱开销 | | 集合存储/对象操作 | `Integer.valueOf()` | 直接获得对象类型 | | 高频使用小数字 (-128~127) | `Integer.valueOf()` | 利用缓存减少对象创建 | | 不确定输入是否有效 | 结合 `try-catch` | 统一处理 `NumberFormatException` | > **经验法则**:需要 `int` 用 `parseInt`,需要 `Integer` 用 `valueOf`([^5]) --- #### 示例场景对比 ```java // 场景1:简单计算(parseInt 更优) int total = Integer.parseInt("500") * 2; // 场景2:放入HashMap(valueOf 更优) Map<String, Integer> map = new HashMap<>(); map.put("count", Integer.valueOf("100")); // 场景3:缓存优化(valueOf 节省内存) List<Integer> smallNumbers = Arrays.asList( Integer.valueOf("100"), Integer.valueOf("100") // 复用缓存对象 ); ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值