如何在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 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;
}
#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 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之类的“魔术”表达式
#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("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));
}
}
}
#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来处理这种特殊情况。 由于Java不提供这种方法，因此我使用以下包装器：
private Optional 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)); // 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;
}
#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 = 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等。