如何在Java中将String转换为int？

如何在Java中将String转换为int ？

我的字符串仅包含数字，我想返回它代表的数字。

例如，给定字符串"1234" ，结果应为数字1234 。

#1楼

好吧，要考虑的一个非常重要的一点是，Integer解析器会抛出Javadoc中所述的NumberFormatException。

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.
}

在尝试从拆分参数中获取整数值或动态解析某些内容时，处理此异常非常重要。

#2楼

手动执行：

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 flagif (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;
}

#3楼

您也可以先删除所有非数字字符，然后解析整数：

String mystr = mystr.replaceAll("[^\\d]", "");
int number = Integer.parseInt(mystr);

但请注意，这仅适用于非负数。

#4楼

将字符串转换为整数比仅转换数字更复杂。您已经考虑了以下问题：

字符串仅包含数字0-9吗？
字符串前后的-/ +是怎么回事？有可能吗（指会计编号）？
MAX _- / MIN_INFINITY怎么了？ 如果字符串是99999999999999999999，会发生什么？机器可以将此字符串视为int吗？

#5楼

目前，我正在为大学做作业，在这里我无法使用某些表达式，例如上面的表达式，通过查看ASCII表，我设法做到了。这是一个复杂得多的代码，但是它可以像我以前那样帮助受限制的其他人。

首先要做的是接收输入，在这种情况下，是一串数字。我将其称为String number ，在这种情况下，我将使用数字12进行示例，因此String number = "12";

另一个局限性是我不能使用重复循环，因此，也不能使用for循环（本来是完美的）。这限制了我们一点，但是再一次，这就是目标。由于我只需要两位数（取最后两位数），所以一个简单的charAt解决了它：

 // Obtaining the integer values of the char 1 and 2 in ASCIIint semilastdigitASCII = number.charAt(number.length()-2);int lastdigitASCII = number.charAt(number.length()-1);

有了代码，我们只需要查看表格，并进行必要的调整：

 double semilastdigit = semilastdigitASCII - 48;  //A quick look, and -48 is the keydouble 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之类的“魔术”表达式

#6楼

我有一个解决方案，但我不知道它有多有效。但是它运作良好，我认为您可以改善它。另一方面，我对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("Notis 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));}}
}

#7楼

另一种解决方案是使用Apache Commons的 NumberUtils：

int num = NumberUtils.toInt("1234");

Apache实用程序很好，因为如果字符串是无效的数字格式，则始终返回0。因此可以节省您的try catch块。

Apache NumberUtils API版本3.4

#8楼

我们可以使用Integer包装器类的parseInt(String str)方法将String值转换为整数值。

例如：

String strValue = "12345";
Integer intValue = Integer.parseInt(strVal);

Integer类还提供了valueOf(String str)方法：

String strValue = "12345";
Integer intValue = Integer.valueOf(strValue);

我们还可以使用toInt(String strValue) 实用程序类的 toInt(String strValue)进行转换：

String strValue = "12345";
Integer intValue = NumberUtils.toInt(strValue);

#9楼

在采取一些预防措施的同时，您也可以使用此代码。

选项＃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; } 
```

使用字符串常量进行比较或任何类型的计算始终是一个好主意，因为常量永远不会返回空值。

#10楼

`Integer.decode`

您还可以使用public static Integer decode(String nm) throws NumberFormatException 。

它也适用于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(); 
```

#11楼

只要给定的String极有可能不包含Integer，就必须处理这种特殊情况。可悲的是，标准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 1234
System.out.println(tryParseInteger("1234").orElse(-1));
// prints -1
System.out.println(tryParseInteger("foobar").orElse(-1));

尽管这仍在内部使用异常进行流控制，但是用法代码变得非常干净。

#12楼

int foo=Integer.parseInt("1234");

确保字符串中没有非数字数据。

#13楼

如前所述，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;

#14楼

除了前面的答案，我还要添加几个功能。这些是您使用它们时的结果：

public static void main(String[] args) {System.out.println(parseIntOrDefault("123", 0)); // 123System.out.println(parseIntOrDefault("aaa", 0)); // 0System.out.println(parseIntOrDefault("aaa456", 3, 0)); // 456System.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;
}

#15楼

Google Guava具有tryParse（String），如果无法解析该字符串，则返回null ，例如：

Integer fooInt = Ints.tryParse(fooString);
if (fooInt != null) {...
}

#16楼

对于普通字符串，可以使用：

int number = Integer.parseInt("1234");

对于字符串构建器和字符串缓冲区，可以使用：

Integer.parseInt(myBuilderOrBuffer.toString());

#17楼

开始了

String str="1234";
int number = Integer.parseInt(str);
print number;//1234

#18楼

您可以使用new Scanner("1244").nextInt() 。或询问是否存在int： new Scanner("1244").hasNextInt()

#19楼

在编程竞赛中，可以确保数字始终是有效的整数，然后您可以编写自己的方法来解析输入。这将跳过所有与验证相关的代码（因为您不需要任何代码），并且效率更高。

对于有效的正整数：

 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() 。

#20楼

一种方法是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);

#21楼

这是一个完整的程序，无需使用库即可在所有正负条件下运行

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

#22楼

您只需尝试以下操作：

使用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

#23楼

方法如下：

 1. Integer.parseInt(s)2. Integer.parseInt(s, radix)3. Integer.parseInt(s, beginIndex, endIndex, radix)4. Integer.parseUnsignedInt(s)5. Integer.parseUnsignedInt(s, radix)6. Integer.parseUnsignedInt(s, beginIndex, endIndex, radix)7. Integer.valueOf(s)8. Integer.valueOf(s, radix)9. Integer.decode(s)10. NumberUtils.toInt(s)11. NumberUtils.toInt(s, defaultValue)

Integer.valueOf产生Integer对象，所有其他方法-原始int。

commons-lang3和有关此处转换的大型文章的后两种方法。

#24楼

使用Integer.parseInt(yourString) 。

请记住以下几点：

Integer.parseInt("1"); // 好

Integer.parseInt("-1"); // 好

Integer.parseInt("+1"); // 好

Integer.parseInt(" 1"); //异常（空白）

Integer.parseInt("2147483648"); //异常（整数限制为最大值 2,147,483,647）

Integer.parseInt("1.1"); //异常（。或，或不允许的任何东西）

Integer.parseInt(""); //异常（非0或其他值）

仅有一种异常： NumberFormatException

#25楼

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

#26楼

令我惊讶的是，没有人提到将String作为参数的Integer构造函数。

因此，这里是：

String myString = "1234";
int i1 = new Integer(myString);

Java 8-整数（String）。

当然，构造函数将返回Integer类型，并且取消装箱操作会将值转换为int 。

重要的是要提一下 ：此构造函数调用parseInt方法。

public Integer(String var1) throws NumberFormatException {this.value = parseInt(var1, 10);
}

#27楼

它可以通过以下七种方式完成：

import com.google.common.primitives.Ints;
import org.apache.commons.lang.math.NumberUtils;String number = "999";

1）使用Ints.tryParse ：

int result = Ints.tryParse(number);

2）使用NumberUtils.createInteger ：

Integer result = NumberUtils.createInteger(number);

3）使用NumberUtils.toInt ：

int result = NumberUtils.toInt(number);

4）使用Integer.valueOf ：

Integer result = Integer.valueOf(number);

5）使用Integer.parseInt ：

int result = Integer.parseInt(number);

6）使用Integer.decode ：

int result = Integer.decode(number);

7）使用Integer.parseUnsignedInt ：

int result = Integer.parseUnsignedInt(number);

#28楼

您可以使用以下任何一种：

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)

#29楼

String myString = "1234";
int foo = Integer.parseInt(myString);

如果您查看Java文档，您会发现“捕获”是此函数可以引发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)

#30楼

例如，以下两种方式：

Integer x = Integer.valueOf(str);
// or
int y = Integer.parseInt(str);

这些方法之间略有不同：

valueOf返回java.lang.Integer的新实例或缓存的实例
parseInt返回原始int 。

在所有情况下都是相同的： Short.valueOf / parseShort ， Long.valueOf / parseLong等。