Integer.parseInt(String s,int radix)

最新推荐文章于 2025-06-18 18:12:10 发布
最新推荐文章于 2025-06-18 18:12:10 发布
阅读量7.7k 收藏 6
点赞数 4
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/sweetzhangxue/article/details/53006557
本文详细解释了Java中Integer.parseInt(String s, int radix)方法的工作原理，包括如何将不同进制的字符串转换为十进制整数，并给出了具体的转换示例。

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

Integer.parseInt(String s,int radix)返回的结果是一个十进制数

我们是要得到s的十进制数，而radix是表示s当前是多少进制的数

举个例子

parseInt(1010,16)

意思就是：输出16进制数1010在十进制下的数

我们平时用Integer.parseInt("123");默认就调用了int i ＝ Integer.parseInt("123",10);转换过程可以看成如下：

i = 1 * 10*10 + 2 * 10 + 3

int j = Integer.parseInt("123",16)的转换过程可以看成如下：

j = 1 * 16*16 + 2 * 16 + 3;

源码如下：







public static final int MIN_RADIX = 2;
public static final int MAX_RADIX = 36;
public static int parseInt(String string, int radix) throws NumberFormatException {    if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) {        throw new NumberFormatException("Invalid radix: " + radix);    }    if (string == null || string.isEmpty()) {        throw invalidInt(string);    }    char firstChar = string.charAt(0);    int firstDigitIndex = (firstChar == '-' || firstChar == '+') ? 1 : 0;    if (firstDigitIndex == string.length()) {        throw invalidInt(string);    }    return parse(string, firstDigitIndex, radix, firstChar == '-');}






根据源码可以看出radix的范围是在2——36之间，超出范围会抛异常。


s的长度也不能超出7，否则也会抛异常







                

        

    

    
  



    

      

        

            

              
                
                  sweetzhangxue
                
              
            

            

                关注
              
            

        

        

          
      

      










                



	

		

			

				
					
Integer.parseInt解读

				
			

			

				

					bdmh的专栏
				

				

					05-13
					
					2万+
					
				

			

		

		

			
				
int I = Integer.parseInt("123456");

当我们要把字符串转成整数时，最常用的就是上面的一行代码，现在就看看 parseInt 是如何实现的

当执行上述代码时，系统默认按照十进制转换


    public static int parseInt(String s) throws NumberFormatException {
        return p...

			
		

	



                

            
              



	

		

			

				
					
Integer.parseInt()小记（字符串转int）

				
			

			

				

					还有头发的沛沛的博客
				

				

					05-24
					
					2446
					
				

			

		

		

			
				
字符串转int（Integer.parseInt()函数）
在牛客上看到一个字符串转int类型的题目，感觉看上去没什么难度，但是自己做的过程中，对于int越界判断做的较为复杂，翻看了Integer.parseInt()的源码之后，惊叹其清晰的逻辑判断。顺便吐槽下牛客网的测试用例中对于int类型越界判断有些问题，如图：
源码解读：

默认情况下，我们调用parseInt(String s)函数，其默认为十进制，转而调用parseInt(String s, int radix)方法。再次方法中先如下图所示，对字

			
		

	



              


  
              

                


	

		

			

				
					
Integer.parseInt(String s ,int radix)  详解+源码

				
			

			

				

					lww0407的博客
				

				

					07-02
					
					1354
					
				

			

		

		

			
				
方法parseInt(String s,int radix)的目的是输出一个十进制数，输入参数“String s”，后面“int radix”代表该数字的进制，通过该方法将指定进制的数字转化成10进制输出返回。
比如：parseInt(1010,2)
意思就是：输出2进制数1010在十进制下的数.
更直白地说：parseInt(String s,int radix)就是求“int radix”进制数“String s”的十进制数是多少。
我们平时用的Integer valueOf(String s)，调用的

			
		

	





	

		

			

				
					
Integer.parseInt(String s, int radix)方法介绍（修正版）

					
热门推荐

				
			

			

				

					团长只是我的小名。
				

				

					07-19
					
					1万+
					
				

			

		

		

			
				
Integer.parseInt(String s, int radix)就是将字符串s转换成radix进制的整数,显然前提是s为整数字符串。比如 s可以为“1314520”、“5201314”等。不可以为“我爱你一生一世”或者“I love you  forever”等之类的非整数字符串。
       那么，Integer.pareseInt("10086",10)就是将整数字符串“10086”转换成10进制的整数10086。

			
		

	



		

			
		



	

		

			

				
					
JavaScript 数据处理 - parseInt 函数解读（参数 str 解读、参数 radix 解读）

				
			

			

				

					weixin_52173250的博客
				

				

					06-18
					
					1127
					
				

			

		

		

			
				
JavaScript 数据处理 - parseInt 函数解读（参数 str 解读、参数 radix 解读）

			
		

	





	

		

			

				
					
Integer.parseInt（String s，int radix）方法

				
			

			

				

					Miaoshuowen的博客
				

				

					09-27
					
					1486
					
				

			

		

		

			
				
parseInt(String s, int radix）
parseInt
public static int parseInt(String s,
                           int radix)
                    throws NumberFormatException

使用第二个参数指定的基数，将字符串参数解析为有符号的整数。除了第一个字符...

			
		

	





	

		

			

				
					
Integer.parseInt(String s ,int radix)方法解析

				
			

			

				

					HD243608836的博客
				

				

					02-22
					
					1229
					
				

			

		

		

			
				
Integer.parseInt(String s,int radix)的目的是输出一个十进制数（方法中“int radix”参数用来表明“String s”是多少进制的）。 

----------------------- ----------------------- ----------------------- ----------------------- --------------...

			
		

	





	

		

			

				
					
Integer.parseInt(String s ,int radix)方法使用解释

				
			

			

				

					weixin_33918357的博客
				

				

					05-06
					
					2076
					
				

			

		

		

			
				
方法parseInt(String s,int radix)的目的是输出一个十进制数，这个数字是“String s”但是我们要知道他是多少进制的，而方法中“int radix”参数正是来表达这个信息的。比如：parseInt(1010,2)意思就是：输出2进制数1010在十进制下的数.更直白地说：parseInt(String s,int rad...

			
		

	





	

		

			

				
					
Integer.parseInt(String s, int radix)和Integer.valueOf(String s, int radix)对比分析

				
			

			

				

					jerry_player的博客
				

				

					04-16
					
					1679
					
				

			

		

		

			
				
背景
之前在code review 的时候，发现有同学直接使用“==”判断两个Integer是否相等，这有问题吗？相信大家对这个都有自己对看法。另外今早上在地铁上听到有人说Integer.parseInt(String s, int radix)返回是int类型,其中radix取值范围是2～36，s长度不能超过7，这种说法对吗？故写此文章来发表自己看法

Integer.parseInt和Inte...

			
		

	





	

		

			

				
					
进制转换（Integer.parseInt(num.int radix)）

				
			

			

				

					wangdongli_1993的博客
				

				

					08-21
					
					2137
					
				

			

		

		

			
				
题目描述

写出一个程序，接受一个十六进制的数值字符串，输出该数值的十进制字符串。（多组同时输入 ）

输入描述:

输入一个十六进制的数值字符串。

输出描述:

输出该数值的十进制字符串。

示例1

输入


0xA

输出


10

 （1）利用Integer自带的进制转换方法实现


package xidian.lili.huawei;
import java.util.Scanne...

			
		

	





	

		

			

				
					
【java学习笔记（零散知识点）】Integer类 parseInt(String s ,int radix)方法

				
			

			

				

					pcpeng1426的博客
				

				

					09-17
					
					322
					
				

			

		

		

			
				
parseInt(String s , int radix) ：求 “int radix” 进制数 “String s” 的十进制数
e.g parseInt(1010,2) ：输出 2进制数 1010 的十进制数


int radix 缺省值为10 即 parseInt（String s）=parseInt（String s ， 10）


ps: radix的范围是在2~36之

			
		

	





	

		

			

				
					
Integer.parseInt()可以进行进制转换

				
			

			

				

					qq_47627886的博客
				

				

					10-15
					
					1562
					
				

			

		

		

			
				
Scanner sc = new Scanner(System.in);
		String s = sc.next();
		System.out.println(Integer.parseInt(s,2));

如图，Integer.parseInt(s,2)的作用就是将字符串s看作二进制转换为十进制




			
		

	





	

		

			

				
					
关于Integer的parseInt(String s, int radix)方法的使用

				
			

			

				

					xiaoxiaow的博客
				

				

					03-10
					
					358
					
				

			

		

		

			
				
最近看了一些别人写的java程序，其中就用到Integer.parseInt("23f34d",16);这个方法，当时很不解。
在网上搜了一下，才明白原来是这样的。
 
首先可以看一下jdk中 java.lang.Integer中的源码如下：
public static int parseInt(String s) throws NumberFormatException 
{
	re...

			
		

	





	

		

			

				
					
Integer.parseInt(String s, int radix)的使用方法

				
			

			

				

					Oasis
				

				

					12-07
					
					2021
					
				

			

		

		

			
				
我们经常使用Integer.parseInt(String s)将一个字符串转换成十进制的数字，其实它内部的调用使用的下面的代码：
源码如下：
public static int parseInt(String s) throws NumberFormatException {
	return parseInt(s,10);
}

可以看到它其实调用的parseInt(String s, int radix)方法，只是第二个参数默认传的是10，也就是默认字符串s的格式为十进制数字的字符串。我们再看一下它具体

			
		

	





	

		

			

				
					
Integer.parseInt()的用法

				
			

			

				

					m0_74051652的博客
				

				

					08-08
					
					3160
					
				

			

		

		

			
				
是 Java 中的一个静态方法，用于将字符串参数作为有符号的整数进行解析。这个方法可以解析十进制、十六进制、八进制等进制的字符串表示形式，具体取决于第二个参数radix的值。

			
		

	





	

		

			

				
					
java中Integer.parseInt(String)与Integer.valueOf(String)区别

				
			

			

				

					programmer_at的专栏
				

				

					03-07
					
					1万+
					
				

			

		

		

			
				
接口描述：
valueOf() 
返回一个Integer对象持有指定的原始值

parseInt() 
此方法用于获取某个字符串的原始数据类型

说白了，Integer.valueOf(String)是将String转化为Integer对象
Integer.parseInt(String)是将String转化为int



直接上代码：
package helloproj

			
		

	





	

		

			

				
					
java 关于 Integer.parseInt转16进制问题

				
			

			

				

					qq_54502508的博客
				

				

					11-09
					
					762
					
				

			

		

		

			
				
java 关于 Integer.parseInt转16进制问题

			
		

	





	

		

			

				
					
Integer 十六进制

				
			

			

				

					洪君的博客
				

				

					04-10
					
					1041
					
				

			

		

		

			
				
integer ：

两个integer比较，且大于128，出现不相等问题

解决方案：使用 equals ，保存前面第一个integer不为空



十进制转十六进制




public static Integer toHex(String s) {
        if (BaU.fullObj(s)) {
            return Integer.valueOf(s, 1...

			
		

	





	

		

			

				
					
Integer.parseInt(String)和Integer.valueOf(String)的区别

					
最新发布

				
			

			

				

					07-25
				

			

		

		

			
				
<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()返回int，Integer.valueOf()返回int的封装类Integer。

> 通常情况下，如果只需要使用整数的值而不需要Integer对象，建议使用Integer.parseInt(str)方法。如果需要将整数作为对象进行操作，则可以使用Integer.valueOf(str)。

因此，我们可以这样总结：

- 如果你需要一个基本类型 `int`，那么使用 `parseInt` 更合适。
- 如果你需要一个 `Integer` 对象（例如要放入集合中，或者需要使用对象的方法），那么使用 `valueOf` 更合适。

另外，引用[3]提到：
> 当参数类型为String时，Integer.ParseInt(String)返回int，Integer.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、付费专栏及课程。

              

            

          

      

      余额充值