如何在 Java 中将 String 转换为 int？
Posted
技术标签:
【中文标题】如何在 Java 中将 String 转换为 int？【英文标题】：How do I convert a String to an int in Java? 【发布时间】：2011-07-31 22:38:01 【问题描述】：如何在 Java 中将 String 转换为 int？
我的字符串只包含数字，我想返回它所代表的数字。
例如，给定字符串"1234"，结果应该是数字1234。
【问题讨论】：
顺便提一下，如果字符串为null，调用：int i = Integer.parseInt(null);抛出 NumberFormatException，而不是 NullPointerException。 当规范的一个重要部分缺失时，这个问题应该得到如此高的评价，我有点惊讶：如果字符串不只包含数字会发生什么？例如，许多答案会愉快地解析“-1”并返回 -1，但我们不知道这是否可以接受。 【参考方案1】：String myString = "1234";
int foo = Integer.parseInt(myString);
如果您查看Java documentation，您会注意到“捕获”是此函数可以抛出NumberFormatException，这当然是您必须处理的：
int foo;
try
foo = Integer.parseInt(myString);
catch (NumberFormatException e)
foo = 0;
（此处理默认为0，但您可以根据需要执行其他操作。）
或者，您可以使用 Guava 库中的 Ints 方法，该方法与 Java 8 的 Optional 结合使用，是一种将字符串转换为 int 的强大而简洁的方法：
import com.google.common.primitives.Ints;
int foo = Optional.ofNullable(myString)
.map(Ints::tryParse)
.orElse(0)
【讨论】：
除了捕获 NumberFormatException 之外，用户还应该注意他们传入的字符串的长度；如果它们的长度足以溢出整数，则可能需要考虑使用 Long::parseLong 来代替。【参考方案2】：例如，这里有两种方式：
Integer x = Integer.valueOf(str);
// or
int y = Integer.parseInt(str);
这些方法之间存在细微差别：
valueOf 返回 java.lang.Integer 的新实例或缓存实例
parseInt 返回原始 int。
所有情况都相同：Short.valueOf/parseShort、Long.valueOf/parseLong 等
【讨论】：
两种方式的区别见this questionvalueOf 方法就是return valueOf(parseInt(string));【参考方案3】：
嗯，需要考虑的一个非常重要的点是整数解析器抛出 NumberFormatException，如Javadoc 中所述。
int foo;
String StringThatCouldBeANumberOrNot = "26263Hello"; //will throw exception
String StringThatCouldBeANumberOrNot2 = "26263"; //will not throw exception
try
foo = Integer.parseInt(StringThatCouldBeANumberOrNot);
catch (NumberFormatException e)
//Will Throw exception!
//do something! anything to handle the exception.
try
foo = Integer.parseInt(StringThatCouldBeANumberOrNot2);
catch (NumberFormatException e)
//No problem this time, but still it is good practice to care about exceptions.
//Never trust user input :)
//Do something! Anything to handle the exception.
在尝试从拆分参数中获取整数值或动态解析某些内容时，处理此异常很重要。
【讨论】：
如何解析“26263Hello”？在那种情况下我想提取26263 @user463035818 - 参见docs.oracle.com/javase/8/docs/api/java/util/regex/… -"([0-9]+)" 的正则表达式模式将“捕获”一个或多个数字从一到九的第一个序列。查看该包中的 Matcher 类。【参考方案4】：
手动操作：
public static int strToInt(String str)
int i = 0;
int num = 0;
boolean isNeg = false;
// Check for negative sign; if it's there, set the isNeg flag
if (str.charAt(0) == '-')
isNeg = true;
i = 1;
// Process each character of the string;
while( i < str.length())
num *= 10;
num += str.charAt(i++) - '0'; // Minus the ASCII code of '0' to get the value of the charAt(i++).
if (isNeg)
num = -num;
return num;
【讨论】：
如果输入大于2^32怎么办？如果输入包含非数字字符怎么办？ 程序员在加入劳动力队伍时必须学习的一件事，如果不是以前的话，那就是永远不要重新发明***。这可能是一个有趣的练习，但如果你在商业环境中做这种事情，不要指望你的代码能通过代码审查。 -1 抱歉，这是一个非常糟糕的算法，有很多限制，没有错误处理，还有一些奇怪的异常（例如，“”给出异常，“-”将产生 0，以及“ +" 产生 -5)。为什么有人会选择这个而不是Integer.parseInt(s)？ - 我明白这是一个面试问题的意义，但是a）这并不意味着你会这样做（这是提问者所问的），并且b）这个答案无论如何都是一个非常糟糕的例子。
-1 因为如果我想解析一个基数为 31 的 int 怎么办？ Integer.parseInt(str, 31) 是这样做的。有点滑稽的评论，但下面是严肃的一点。当别人已经投入工作时，永远不要重新发明***
这段代码看起来像是改编自一个著名的库，用于在竞争性编程竞赛中进行快速 IO。在这种情况下，输入数据保证有效，解决方案按速度分级。它应该比Integer.parseInt 更快因为它不进行验证。【参考方案5】：
另一种解决方案是使用Apache Commons' NumberUtils：
int num = NumberUtils.toInt("1234");
Apache 实用程序很好，因为如果字符串是无效的数字格式，则总是返回 0。因此为您节省了 try catch 块。
Apache NumberUtils API Version 3.4
【讨论】：
您很少希望在解析无效数字时使用 0。 @Ryboflavin 不，它没有。其中一个是定义明确的语言语义，另一个是例外【参考方案6】：Integer.decode
您也可以使用public static Integer decode(String nm) throws NumberFormatException。
它也适用于 base 8 和 16：
// base 10
Integer.parseInt("12"); // 12 - int
Integer.valueOf("12"); // 12 - Integer
Integer.decode("12"); // 12 - Integer
// base 8
// 10 (0,1,...,7,10,11,12)
Integer.parseInt("12", 8); // 10 - int
Integer.valueOf("12", 8); // 10 - Integer
Integer.decode("012"); // 10 - Integer
// base 16
// 18 (0,1,...,F,10,11,12)
Integer.parseInt("12",16); // 18 - int
Integer.valueOf("12",16); // 18 - Integer
Integer.decode("#12"); // 18 - Integer
Integer.decode("0x12"); // 18 - Integer
Integer.decode("0X12"); // 18 - Integer
// base 2
Integer.parseInt("11",2); // 3 - int
Integer.valueOf("11",2); // 3 - Integer
如果您想获得int 而不是Integer，您可以使用：
拆箱：
int val = Integer.decode("12");
intValue():
Integer.decode("12").intValue();
【讨论】：
【参考方案7】：目前我正在为大学做作业，我不能使用某些表达式，例如上面的那些，通过查看 ASCII 表，我设法做到了。这是一个复杂得多的代码，但它可以帮助像我一样受到限制的其他人。
首先要做的是接收输入，在这种情况下是一串数字；我将其称为String number，在这种情况下，我将使用数字 12 来举例说明，因此String number = "12";
另一个限制是我不能使用重复循环，因此也不能使用for 循环（这本来是完美的）。这限制了我们一点，但话又说回来，这就是目标。因为我只需要两位数（取最后两位数），一个简单的charAt解决了它：
// Obtaining the integer values of the char 1 and 2 in ASCII
int semilastdigitASCII = number.charAt(number.length() - 2);
int lastdigitASCII = number.charAt(number.length() - 1);
有了代码，我们只需要查看表格，并进行必要的调整：
double semilastdigit = semilastdigitASCII - 48; // A quick look, and -48 is the key
double lastdigit = lastdigitASCII - 48;
现在，为什么要加倍？好吧，因为一个非常“奇怪”的步骤。目前我们有两个双精度数，1 和 2，但是我们需要把它变成 12，没有任何数学运算可以做。
我们以2/10 = 0.2（因此为什么要加倍）的方式将后者（最后一位）除以 10，如下所示：
lastdigit = lastdigit / 10;
这只是在玩数字。我们把最后一位数字变成了小数。但是现在，看看会发生什么：
double jointdigits = semilastdigit + lastdigit; // 1.0 + 0.2 = 1.2
无需过多研究数学，我们只是将数字的位数隔离开来。你看，因为我们只考虑 0-9，除以 10 的倍数就像创建一个“盒子”来存储它（回想一下你一年级的老师向你解释什么是单位和一百）。所以：
int finalnumber = (int) (jointdigits*10); // Be sure to use parentheses "()"
然后就可以了。考虑到以下限制，您将一串数字（在本例中为两位数）转换为由这两位数组成的整数：
没有重复循环 没有“魔术”表达式，例如 parseInt【讨论】：
目前尚不清楚这个答案试图解决什么样的问题，首先，为什么任何人都应该有你描述的那个限制，其次，为什么你必须查看一个 ASCII 表，因为你可以简单地使用 @ 987654331@ 代替48 的字符，并且永远不必打扰它的实际数值。第三，使用double 值的整个绕道根本没有意义，因为您要除以十，然后再乘以十。结果简直就是semilastdigit * 10 + lastdigit，就像小学时引入的十进制系统一样……【参考方案8】：
方法：
Integer.parseInt(s)
Integer.parseInt(s, radix)
Integer.parseInt(s, beginIndex, endIndex, radix)
Integer.parseUnsignedInt(s)
Integer.parseUnsignedInt(s, radix)
Integer.parseUnsignedInt(s, beginIndex, endIndex, radix)
Integer.valueOf(s)
Integer.valueOf(s, radix)
Integer.decode(s)
NumberUtils.toInt(s)
NumberUtils.toInt(s, defaultValue)
Integer.valueOf 生成一个 Integer 对象，所有其他方法生成一个原始 int。
最后两种方法来自commons-lang3和一篇关于转换here的大文章。
【讨论】：
【参考方案9】：只要给定字符串不包含整数的可能性很小，您就必须处理这种特殊情况。遗憾的是，标准的 Java 方法 Integer::parseInt 和 Integer::valueOf 会抛出 NumberFormatException 来表示这种特殊情况。因此，您必须使用异常来进行流控制，这通常被认为是糟糕的编码风格。
在我看来，这种特殊情况应该通过返回一个空的Optional<Integer> 来处理。由于 Java 不提供这样的方法，所以我使用以下包装器：
private Optional<Integer> tryParseInteger(String string)
try
return Optional.of(Integer.valueOf(string));
catch (NumberFormatException e)
return Optional.empty();
示例用法：
// prints "12"
System.out.println(tryParseInteger("12").map(i -> i.toString()).orElse("invalid"));
// prints "-1"
System.out.println(tryParseInteger("-1").map(i -> i.toString()).orElse("invalid"));
// prints "invalid"
System.out.println(tryParseInteger("ab").map(i -> i.toString()).orElse("invalid"));
虽然这仍然在内部使用异常进行流控制，但使用代码变得非常干净。此外，您可以清楚地区分-1 被解析为有效值的情况和无法解析无效String 的情况。
【讨论】：
【参考方案10】：使用Integer.parseInt(yourString)。
记住以下几点：
Integer.parseInt("1"); // 好的
Integer.parseInt("-1"); // 好的
Integer.parseInt("+1"); // 好的
Integer.parseInt(" 1"); // 异常（空格）
Integer.parseInt("2147483648"); // 异常（整数仅限于 maximum value 的 2,147,483,647）
Integer.parseInt("1.1"); // 异常（. 或 , 或任何不允许的）
Integer.parseInt(""); // 异常（不是0什么的）
只有一种异常：NumberFormatException
【讨论】：
【参考方案11】：将字符串转换为 int 比仅转换数字更复杂。您考虑过以下问题：
字符串是否只包含数字0-9？ -/+ 在字符串之前或之后是怎么回事？这可能吗（指会计数字）？ MAX_-/MIN_INFINITY 是怎么回事？如果字符串是 99999999999999999999 会发生什么？机器能把这个字符串当成int吗？【讨论】：
【参考方案12】：我们可以使用Integer 包装类的parseInt(String str) 方法将字符串值转换为整数值。
例如：
String strValue = "12345";
Integer intValue = Integer.parseInt(strVal);
Integer 类还提供了valueOf(String str) 方法：
String strValue = "12345";
Integer intValue = Integer.valueOf(strValue);
我们也可以使用toInt(String strValue) 的NumberUtils Utility Class 进行转换：
String strValue = "12345";
Integer intValue = NumberUtils.toInt(strValue);
【讨论】：
【参考方案13】：我有一个解决方案，但我不知道它的效果如何。但它运作良好，我认为你可以改进它。另一方面，我用JUnit 做了几个测试，哪个步骤正确。我附上了功能和测试：
static public Integer str2Int(String str)
Integer result = null;
if (null == str || 0 == str.length())
return null;
try
result = Integer.parseInt(str);
catch (NumberFormatException e)
String negativeMode = "";
if(str.indexOf('-') != -1)
negativeMode = "-";
str = str.replaceAll("-", "" );
if (str.indexOf('.') != -1)
str = str.substring(0, str.indexOf('.'));
if (str.length() == 0)
return (Integer)0;
String strNum = str.replaceAll("[^\\d]", "" );
if (0 == strNum.length())
return null;
result = Integer.parseInt(negativeMode + strNum);
return result;
使用 JUnit 进行测试：
@Test
public void testStr2Int()
assertEquals("is numeric", (Integer)(-5), Helper.str2Int("-5"));
assertEquals("is numeric", (Integer)50, Helper.str2Int("50.00"));
assertEquals("is numeric", (Integer)20, Helper.str2Int("$ 20.90"));
assertEquals("is numeric", (Integer)5, Helper.str2Int(" 5.321"));
assertEquals("is numeric", (Integer)1000, Helper.str2Int("1,000.50"));
assertEquals("is numeric", (Integer)0, Helper.str2Int("0.50"));
assertEquals("is numeric", (Integer)0, Helper.str2Int(".50"));
assertEquals("is numeric", (Integer)0, Helper.str2Int("-.10"));
assertEquals("is numeric", (Integer)Integer.MAX_VALUE, Helper.str2Int(""+Integer.MAX_VALUE));
assertEquals("is numeric", (Integer)Integer.MIN_VALUE, Helper.str2Int(""+Integer.MIN_VALUE));
assertEquals("Not
is numeric", null, Helper.str2Int("czv.,xcvsa"));
/**
* Dynamic test
*/
for(Integer num = 0; num < 1000; num++)
for(int spaces = 1; spaces < 6; spaces++)
String numStr = String.format("%0"+spaces+"d", num);
Integer numNeg = num * -1;
assertEquals(numStr + ": is numeric", num, Helper.str2Int(numStr));
assertEquals(numNeg + ": is numeric", numNeg, Helper.str2Int("- " + numStr));
【讨论】：
【参考方案14】：Google Guava 有tryParse(String)，如果无法解析字符串，则返回null，例如：
Integer fooInt = Ints.tryParse(fooString);
if (fooInt != null)
...
【讨论】：
【参考方案15】：您也可以先删除所有非数字字符，然后解析整数：
String mystr = mystr.replaceAll("[^\\d]", "");
int number = Integer.parseInt(mystr);
但请注意，这只适用于非负数。
【讨论】：
这会导致-42被解析为42。【参考方案16】：
除了前面的答案，我想添加几个功能。这些是您使用时的结果：
public static void main(String[] args)
System.out.println(parseIntOrDefault("123", 0)); // 123
System.out.println(parseIntOrDefault("aaa", 0)); // 0
System.out.println(parseIntOrDefault("aaa456", 3, 0)); // 456
System.out.println(parseIntOrDefault("aaa789bbb", 3, 6, 0)); // 789
实施：
public static int parseIntOrDefault(String value, int defaultValue)
int result = defaultValue;
try
result = Integer.parseInt(value);
catch (Exception e)
return result;
public static int parseIntOrDefault(String value, int beginIndex, int defaultValue)
int result = defaultValue;
try
String stringValue = value.substring(beginIndex);
result = Integer.parseInt(stringValue);
catch (Exception e)
return result;
public static int parseIntOrDefault(String value, int beginIndex, int endIndex, int defaultValue)
int result = defaultValue;
try
String stringValue = value.substring(beginIndex, endIndex);
result = Integer.parseInt(stringValue);
catch (Exception e)
return result;
【讨论】：
【参考方案17】：如前所述，Apache Commons 的NumberUtils 可以做到。如果无法将字符串转换为 int，则返回 0。
您也可以定义自己的默认值：
NumberUtils.toInt(String str, int defaultValue)
例子：
NumberUtils.toInt("3244", 1) = 3244
NumberUtils.toInt("", 1) = 1
NumberUtils.toInt(null, 5) = 5
NumberUtils.toInt("Hi", 6) = 6
NumberUtils.toInt(" 32 ", 1) = 1 // Space in numbers are not allowed
NumberUtils.toInt(StringUtils.trimToEmpty(" 32 ", 1)) = 32;
【讨论】：
【参考方案18】：您也可以使用此代码，但要注意一些预防措施。
选项 #1：显式处理异常，例如，显示消息对话框，然后停止当前工作流的执行。例如：
try
String stringValue = "1234";
// From String to Integer
int integerValue = Integer.valueOf(stringValue);
// Or
int integerValue = Integer.ParseInt(stringValue);
// Now from integer to back into string
stringValue = String.valueOf(integerValue);
catch (NumberFormatException ex)
//JOptionPane.showMessageDialog(frame, "Invalid input string!");
System.out.println("Invalid input string!");
return;
选项#2：如果发生异常时执行流程可以继续，则重置受影响的变量。例如，在 catch 块中进行一些修改
catch (NumberFormatException ex)
integerValue = 0;
使用字符串常量进行比较或任何类型的计算总是一个好主意，因为常量永远不会返回空值。
【讨论】：
【参考方案19】：您可以使用new Scanner("1244").nextInt()。或者询问是否存在 int：new Scanner("1244").hasNextInt()
【讨论】：
【参考方案20】：在编程比赛中，如果您确信数字始终是有效整数，那么您可以编写自己的方法来解析输入。这将跳过所有与验证相关的代码（因为您不需要任何代码）并且效率会更高。
对于有效的正整数：
private static int parseInt(String str)
int i, n = 0;
for (i = 0; i < str.length(); i++)
n *= 10;
n += str.charAt(i) - 48;
return n;
对于正整数和负整数：
private static int parseInt(String str)
int i=0, n=0, sign=1;
if (str.charAt(0) == '-')
i = 1;
sign = -1;
for(; i<str.length(); i++)
n* = 10;
n += str.charAt(i) - 48;
return sign*n;
如果您希望在这些数字之前或之后有空格，
然后确保在进一步处理之前执行str = str.trim()。
【讨论】：
【参考方案21】：你可以试试这个：
使用Integer.parseInt(your_string); 将String 转换为int
使用Double.parseDouble(your_string); 将String 转换为double
示例
String str = "8955";
int q = Integer.parseInt(str);
System.out.println("Output>>> " + q); // Output: 8955
String str = "89.55";
double q = Double.parseDouble(str);
System.out.println("Output>>> " + q); // Output: 89.55
【讨论】：
【参考方案22】：对于普通字符串，您可以使用：
int number = Integer.parseInt("1234");
对于字符串生成器和字符串缓冲区，您可以使用：
Integer.parseInt(myBuilderOrBuffer.toString());
【讨论】：
【参考方案23】：我有点惊讶没有人提到将 String 作为参数的 Integer 构造函数。
所以，这里是：
String myString = "1234";
int i1 = new Integer(myString);
Java 8 - Integer(String).
当然，构造函数会返回类型Integer，而拆箱操作会将值转换为int。
注意 1：重要的是要提及：此构造函数调用 parseInt 方法。
public Integer(String var1) throws NumberFormatException
this.value = parseInt(var1, 10);
注意 2：已弃用：@Deprecated(since="9") - JavaDoc。
【讨论】：
Integer constructors are derpecated【参考方案24】：使用 Integer.parseInt() 并将其放入 try...catch 块中以处理任何错误，以防输入非数字字符，例如，
private void ConvertToInt()
String string = txtString.getText();
try
int integerValue=Integer.parseInt(string);
System.out.println(integerValue);
catch(Exception e)
JOptionPane.showMessageDialog(
"Error converting string to integer\n" + e.toString,
"Error",
JOptionPane.ERROR_MESSAGE);
【讨论】：
【参考方案25】：可以通过七种方式完成：
import com.google.common.primitives.Ints;
import org.apache.commons.lang.math.NumberUtils;
String number = "999";
Ints.tryParse:
int 结果 = Ints.tryParse(number);
NumberUtils.createInteger:
整数结果 = NumberUtils.createInteger(number);
NumberUtils.toInt:
int 结果 = NumberUtils.toInt(number);
Integer.valueOf:
整数结果 = Integer.valueOf(number);
Integer.parseInt:
int 结果 = Integer.parseInt(number);
Integer.decode:
int 结果 = Integer.decode(number);
Integer.parseUnsignedInt:
int 结果 = Integer.parseUnsignedInt(number);
【讨论】：
NumberUtils 也可以处理 null 和空场景。【参考方案26】：int foo = Integer.parseInt("1234");
确保字符串中没有非数字数据。
【讨论】：
这和选择的答案完全一样。 重复别人在您之前五年发布的答案对网站没有任何价值。 这已经在the accepted answer 中介绍过（大约 5 年前发布）。【参考方案27】：我们来了
String str = "1234";
int number = Integer.parseInt(str);
print number; // 1234
【讨论】：
这已经在the accepted answer 中介绍过（大约 5 年前发布）。【参考方案28】：这是一个完整的程序，所有条件为正和负，无需使用库
import java.util.Scanner;
public class StringToInt
public static void main(String args[])
String inputString;
Scanner s = new Scanner(System.in);
inputString = s.nextLine();
if (!inputString.matches("([+-]?([0-9]*[.])?[0-9]+)"))
System.out.println("Not a Number");
else
Double result2 = getNumber(inputString);
System.out.println("result = " + result2);
public static Double getNumber(String number)
Double result = 0.0;
Double beforeDecimal = 0.0;
Double afterDecimal = 0.0;
Double afterDecimalCount = 0.0;
int signBit = 1;
boolean flag = false;
int count = number.length();
if (number.charAt(0) == '-')
signBit = -1;
flag = true;
else if (number.charAt(0) == '+')
flag = true;
for (int i = 0; i < count; i++)
if (flag && i == 0)
continue;
if (afterDecimalCount == 0.0)
if (number.charAt(i) - '.' == 0)
afterDecimalCount++;
else
beforeDecimal = beforeDecimal * 10 + (number.charAt(i) - '0');
else
afterDecimal = afterDecimal * 10 + number.charAt(i) - ('0');
afterDecimalCount = afterDecimalCount * 10;
if (afterDecimalCount != 0.0)
afterDecimal = afterDecimal / afterDecimalCount;
result = beforeDecimal + afterDecimal;
else
result = beforeDecimal;
return result * signBit;
【讨论】：
无需重新发明***，使用Integer.parseInt即可。
@TobiasWeimer 是的，我们可以这样做，但这是不使用库
@TobiasWeimer，有些人需要这个如何不使用库。
不，没有人需要它，因为它是JDK内部的一个函数，而不是一些第三方插件。【参考方案29】：
一种方法是 parseInt(String)。它返回一个原始 int：
String number = "10";
int result = Integer.parseInt(number);
System.out.println(result);
第二种方法是valueOf(String)，它返回一个新的Integer()对象：
String number = "10";
Integer result = Integer.valueOf(number);
System.out.println(result);
【讨论】：
之前的答案中没有提到吗？【参考方案30】：执行此操作的两种主要方法是使用Integer 类的方法valueOf() 和方法parseInt()。
假设给你一个这样的字符串
String numberInString = "999";
然后你可以通过使用将其转换为整数
int numberInInteger = Integer.parseInt(numberInString);
另外，您可以使用
int numberInInteger = Integer.valueOf(numberInString);
但这里的问题是，Integer.valueOf() 方法在Integer 类中具有以下实现：
public static Integer valueOf(String var0, int var1) throws NumberFormatException
return parseInt(var0, var1);
如您所见，Integer.valueOf() 在内部调用Integer.parseInt() 本身。
此外，parseInt() 返回 int，valueOf() 返回 Integer
【讨论】：
这如何添加任何内容？有几个较旧的答案已经提供了这些方法。请在发布前阅读现有答案。 他在展示一个人的效率大于另一个人的效率。以上是关于如何在 Java 中将 String 转换为 int？的主要内容，如果未能解决你的问题，请参考以下文章
如何在 Java 中将 String[] 数组转换为 InputStream
如何在groovy中将java.lang.String转换为json