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

Question

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

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

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

Answer 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)

Answer 2

方法：

// prints 1234
System.out.println(tryParseInteger("1234").orElse(-1));
// prints -1
System.out.println(tryParseInteger("foobar").orElse(-1));

Integer.valueOf生成Integer对象，所有其他方法 - primitive int。

来自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)的最后两种方法和关于转换commons-lang3的大文章。

Answer 3

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

例如：

Integer

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

Answer 4

我有一个解决方案，但我不知道它有多有效。但它运作良好，我认为你可以改进它。另一方面，我用String strValue = "12345"; Integer intValue = NumberUtils.toInt(strValue);做了几个测试，正确的步骤。我附上了功能和测试：

JUnit

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

Answer 5

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

记住以下事项：

Integer.parseInt(yourString) //好的

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

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

Integer.parseInt("+1"); //例外（空格）

Integer.parseInt(" 1"); //例外（整数仅限于Integer.parseInt("2147483648"); 2,147,483,647）

maximum value //例外（。或，或任何不允许的）

Integer.parseInt("1.1"); //例外（不是0或其他）

只有一种例外：Integer.parseInt("");

Answer 6

番石榴有NumberFormatException，如果无法解析字符串，则会返回tryParse(String)，例如：

null

Answer 7

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

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

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

Answer 8

除了以上这些答案，我想添加几个功能。这些是您使用它们时的结果：

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

执行：

  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
  }

Answer 9

您也可以使用此代码，并采取一些预防措施。

选项＃1：显式处理异常，例如，显示消息对话框，然后停止执行当前工作流。例如： 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; }
选项＃2：如果在异常情况下执行流程可以继续，则重置受影响的变量。例如，在catch块中进行一些修改 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; }

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

Answer 10

如上所述Apache Commons catch (NumberFormatException ex) { integerValue = 0; }可以做到这一点。如果它不能将字符串转换为int，则返回NumberUtils。

您还可以定义自己的默认值。

例：

NumberUtils.toInt(String str, int defaultValue)

Answer 11

你可以使用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;。或者询问是否存在int：new Scanner("1244").nextInt()

Answer 12

例如，有两种方法：

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

这些方法之间略有不同：

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

所有情况都是如此：Short.valueOf / parseShort，Long.valueOf / parseLong等。

Answer 13

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

对于有效的正整数： new Scanner("1244").hasNextInt()
对于正整数和负整数： 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; }。

Answer 14

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

str = str.trim()

对于String builder和String buffer，您可以使用：

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

Answer 15

你可以试试这个：

使用Integer.parseInt(myBuilderOrBuffer.toString());将Integer.parseInt(your_string);转换为String
使用int将Double.parseDouble(your_string);转换为String

Example

double

String str = "8955";
int q = Integer.parseInt(str);
System.out.println("Output>>> " + q); // Output: 8955

Answer 16

String str = "89.55";
double q = Double.parseDouble(str);
System.out.println("Output>>> " + q); // Output: 89.55

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

Answer 17

我有点意外，没有人提到将String作为参数的Integer构造函数。所以，这是：

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

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

当然，构造函数将返回类型Java 8 - Integer(String)，而取消装箱操作会将值转换为Integer。

重要的是要提到此构造函数调用int方法。

parseInt

Answer 18

使用Integer.parseInt（）并将其放在public Integer(String var1) throws NumberFormatException { this.value = parseInt(var1, 10); }块中以处理任何错误，以防万一输入非数字字符，例如，

try...catch

Answer 19

可以通过7种方式完成：

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

1）使用import com.google.common.primitives.Ints; import org.apache.commons.lang.math.NumberUtils; String number = "999";：

Ints.tryParse

2）使用int result = Ints.tryParse(number);：

NumberUtils.createInteger

3）使用Integer result = NumberUtils.createInteger(number);：

NumberUtils.toInt

4）使用int result = NumberUtils.toInt(number);：

Integer.valueOf

5）使用Integer result = Integer.valueOf(number);：

Integer.parseInt

6）使用int result = Integer.parseInt(number);：

Integer.decode

7）使用int result = Integer.decode(number);：

Integer.parseUnsignedInt

Answer 20

开始了

int result = Integer.parseUnsignedInt(number);

Answer 21

一种方法是parseInt（String）返回一个原语int

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

第二种方法是valueOf（String）返回一个新的Integer（）对象。

String number = "10";
int result = Integer.parseInt(number);
System.out.println(result);

Answer 22

这是完整的程序，所有条件都是正面，负面而不使用库

String number = "10";
Integer result = Integer.valueOf(number);
System.out.println(result);

Answer 23

好吧，需要考虑的一个非常重要的一点是，整数解析器抛出了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.
}

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

Answer 24

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

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

Answer 25

手动完成：

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

Answer 26

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

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

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

Apache NumberUtils API Version 3.4

Answer 27

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

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

另一个限制是我不能使用重复循环的事实，因此，也不能使用for循环（本来是完美的）。这限制了我们一点，但话说回来，这就是目标。因为我只需要两位数（取最后两位数字），所以简单的qazxswpo解决它：

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

现在，为什么加倍？好吧，因为一个非常“奇怪”的步骤。目前我们有两个双打，1和2，但是我们需要把它变成12，我们可以做任何数学运算。

我们将后者（lastdigit）除以时尚double semilastdigit = semilastdigitASCII - 48; //A quick look, and -48 is the key double lastdigit = lastdigitASCII - 48;（因为为什么加倍）这样的10：

2/10 = 0.2

这只是玩数字。我们把最后一位数字变成了小数。但现在，看看会发生什么：

 lastdigit = lastdigit/10;

没有太多的数学，我们只是将数字与数字隔离。你知道，因为我们只考虑0-9，除以10的倍数就像创建一个存储它的“盒子”（当你的一年级老师向你解释一个单元和一百个单元时）。所以：

 double jointdigits = semilastdigit + lastdigit; // 1.0 + 0.2 = 1.2

你去吧考虑到以下限制，您将一个数字字符串（在本例中为两位数）转换为由这两个数字组成的整数：

没有重复的循环
没有“魔术”表达，如parseInt

Answer 28

`int finalnumber = (int) (jointdigits*10); // Be sure to use parentheses "()"`

你也可以使用Integer.decode。

它也适用于基数8和16：

public static Integer decode(String nm) throws NumberFormatException

如果你想获得// 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()

Answer 29

只要给定String不包含Integer的可能性最小，就必须处理这种特殊情况。可悲的是，标准的Java方法Integer.decode("12").intValue();和Integer::parseInt抛出一个Integer::valueOf来表示这种特殊情况。因此，您必须使用流控制的异常，这通常被认为是错误的编码风格。

在我看来，这个特殊情况应该通过返回NumberFormatException来处理。由于Java不提供这样的方法，我使用以下包装器：

Optional<Integer>

用法：

private Optional<Integer> tryParseInteger(String string) {
    try {
        return Optional.of(Integer.valueOf(string));
    } catch (NumberFormatException e) {
        return Optional.empty();
    }
}

虽然这仍然在内部使用流控制的异常，但使用代码变得非常干净。

Answer 30

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

字符串只包含数字0-9吗？
怎么了 - / +在字符串之前或之后？这是可能的（指会计数字）？
MAX _- / MIN_INFINITY有什么用？如果字符串是99999999999999999999会发生什么？机器可以将此字符串视为int吗？

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

问题描述投票：2784回答：45

45个回答

Example

`int finalnumber = (int) (jointdigits*10); // Be sure to use parentheses "()"`

最新问题

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

问题描述 投票：2784回答：45

45个回答

Example

int finalnumber = (int) (jointdigits*10); // Be sure to use parentheses "()"

最新问题

问题描述投票：2784回答：45

`int finalnumber = (int) (jointdigits*10); // Be sure to use parentheses "()"`