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

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

如果你看一下Java留档，你会注意到“catch”是这个函数可以抛出一个NumberFormatException，你可以处理：

int foo;try {foo = Integer.parseInt(myString);}catch (NumberFormatException e) {foo = 0;}

（此处理默认格式错误的数字为0，但如果您愿意，可以执行其他操作。）

或者，您可以使用Guava库中的Ints方法，它与Java8的Optional相结合，提供了一种将字符串转换为int的强大而简洁的方法：

import com.google.common.primitives.Ints;
int foo = Optional.ofNullable(myString).map(Ints::tryParse).orElse(0)

例如，这里有两种方法：

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

这些方法之间存在细微差别：

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

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

嗯，需要考虑的一个非常重要的点是整数解析器抛出Javadoc中所述的NumberFormatException。

int foo;String StringThatCouldBeANumberOrNot = "26263Hello"; //will throw exceptionString StringThatCouldBeANumberOrNot2 = "26263"; //will not throw exceptiontry {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.}

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

手动执行：

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

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

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

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

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

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

目前我正在做大学作业，在那里我不能使用某些表达式，比如上面的表达式，通过查看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，我们无法进行任何数学运算。

我们将后者（lastdigit）除以10，方式为2/10 = 0.2（因此为什么是双），如下所示：

 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

我有一个解决方案，但我不知道它有多有效。但它很有效，我认为你可以改进它。另一方面，我用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测试：

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

另一种解决方案是使用ApacheCommon NumberUtils：

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

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

Apache NumberUtils API版本3.4

我们可以使用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) ofNumberUtils工具类进行转换：

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

您也可以使用此代码，但有一些预防措施。

• 选项#1：显式处理异常，例如显示消息对话框，然后停止当前工作流的执行。例如：

  try{String stringValue = "1234";
  // From String to Integerint integerValue = Integer.valueOf(stringValue);
  // Orint integerValue = Integer.ParseInt(stringValue);
  // Now from integer to back into stringstringValue = String.valueOf(integerValue);}catch (NumberFormatException ex) {//JOptionPane.showMessageDialog(frame, "Invalid input string!");System.out.println("Invalid input string!");return;}

• Option #2: Reset the affected variable if the execution flow can continue in case of an exception. For example, with some modifications in the catch block

  catch (NumberFormatException ex) {integerValue = 0;}

Using a string constant for comparison or any sort of computing is always a good idea, because a constant never returns a null value.

Integer.decode

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

它也适用于基数8和16：

// base 10Integer.parseInt("12");     // 12 - intInteger.valueOf("12");      // 12 - IntegerInteger.decode("12");       // 12 - Integer// base 8// 10 (0,1,...,7,10,11,12)Integer.parseInt("12", 8);  // 10 - intInteger.valueOf("12", 8);   // 10 - IntegerInteger.decode("012");      // 10 - Integer// base 16// 18 (0,1,...,F,10,11,12)Integer.parseInt("12",16);  // 18 - intInteger.valueOf("12",16);   // 18 - IntegerInteger.decode("#12");      // 18 - IntegerInteger.decode("0x12");     // 18 - IntegerInteger.decode("0X12");     // 18 - Integer// base 2Integer.parseInt("11",2);   // 3 - intInteger.valueOf("11",2);    // 3 - Integer

如果你想得到int而不是Integer，你可以使用：

1. 拆箱：

   int val = Integer.decode("12");

2. intValue():

   Integer.decode("12").intValue();

每当给定的String不包含整数的可能性最小时，您必须处理这种特殊情况。可悲的是，标准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被解析为有效期的情况和无法解析无效字符串的情况。

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

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

如前所述，Apache Commons的NumberUtils可以做到这一点。如果它无法将字符串转换为int，它将返回0。

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

NumberUtils.toInt(String str, int defaultValue)

示例：

NumberUtils.toInt("3244", 1) = 3244NumberUtils.toInt("", 1)     = 1NumberUtils.toInt(null, 5)   = 5NumberUtils.toInt("Hi", 6)   = 6NumberUtils.toInt(" 32 ", 1) = 1 // Space in numbers are not allowedNumberUtils.toInt(StringUtils.trimToEmpty("  32 ", 1)) = 32;

除了前面的答案，我想添加几个函数。这些是您使用它们时的结果：

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

googleguava有tryParse（String）执行方法，如果字符串无法解析，则返回null，例如：

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

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

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

对于字符串生成器和字符串缓冲区，您可以使用：

Integer.parseInt(myBuilderOrBuffer.toString());

我们出发吧

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

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

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

1. 对于有效的正整数：

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

2. For both positive and negative integers:

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

3. If you are expecting a whitespace before or after these numbers,then make sure to do a str = str.trim() before processing further.

一种方法是parseInt（String）。它返回一个原始int：

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

第二个方法是value eOf（String），它返回一个新的Integer（）对象：

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

这是一个完整的程序，所有条件为正和负，无需使用库

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

这样做的方法：

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。

最后两个方法来自公共资源-lang3和一篇关于转换这里的大文章。

使用#0。

记住以下几点：

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或其他）

只有一种例外：#0

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

我有点惊讶没有人提到将String作为参数的整数构造函数。

所以，这是：

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

Java8-整数（字符串）

当然，构造函数将返回类型Integer，拆箱操作将值转换为int。

注1：值得一提的是：此构造函数调用parseInt方法。

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

注2：已弃用：@Deprecated(since="9")-javadoc。

公共静态int parseInt（String s）抛出NumberFormatException

您可以使用Integer.parseInt()将String转换为int。

将字符串“20”转换为原始int：

String n = "20";int r = Integer.parseInt(n); // Returns a primitive intSystem.out.println(r);

产出-20

如果字符串不包含可解析整数，它将抛出NumberFormatException：

String n = "20I"; // Throws NumberFormatExceptionint r = Integer.parseInt(n);System.out.println(r);

公共静态整数值Of（String s）抛出NumberFormatException

您可以使用Integer.valueOf()。在这种情况下，它将返回一个Integer对象。

String n = "20";Integer r = Integer.valueOf(n); // Returns a new Integer() object.System.out.println(r);

产出-20

参考资料https://docs.oracle.com/en/

使用String的不同输入尝试此代码：

String a = "10";String a = "10ssda";String a = null;String a = "12102";
if(null != a) {try {int x = Integer.ParseInt(a.trim());Integer y = Integer.valueOf(a.trim());//  It will throw a NumberFormatException in case of invalid string like ("10ssda" or "123 212") so, put this code into try catch} catch(NumberFormatException ex) {// ex.getMessage();}}

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

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

1. Ints.tryParse：

   int结果=Ints.try解析（数字）；

2. NumberUtils.createInteger：

   整数结果=NumberUtils.create整数（数字）；

3. NumberUtils.toInt：

   int结果=NumberUtils.toInt（数字）；

4. Integer.valueOf：

   整数结果=Integer.value（数字）；

5. Integer.parseInt：

   int结果=Integer.parseInt（数字）；

6. Integer.decode：

   int结果=Integer.decode（数字）；

7. Integer.parseUnsignedInt：

   int结果=Integer.parseUnsignedInt（num）；

使用Java整数类的parseInt方法将字符串转换为整数。parseInt方法是将字符串转换为int，如果字符串无法转换为int类型，则抛出NumberFormatException。

忽略它可以抛出的异常，使用这个：

int i = Integer.parseInt(myString);

如果由变量myString表示的字符串是一个像“1234”, “200”, “1”,这样的有效整数，它将被转换为一个Javaint。如果它因任何原因失败，更改可能会抛出一个NumberFormatException，所以代码应该更长一点来说明这一点。

例如，JavaString到int的转换方法，控制一个可能的NumberFormatException

public class JavaStringToIntExample{public static void main (String[] args){// String s = "test";  // Use this if you want to test the exception belowString s = "1234";
try{// The String to int conversion happens hereint i = Integer.parseInt(s.trim());
// Print out the value after the conversionSystem.out.println("int i = " + i);}catch (NumberFormatException nfe){System.out.println("NumberFormatException: " + nfe.getMessage());}}}

如果更改尝试失败-在这种情况下，如果您可以尝试将JavaString测试转换为int-整数parseInt进程将抛出NumberFormatException，您必须在try/cat块中处理它。

import java.util.*;
public class strToint {
public static void main(String[] args) {
String str = "123";byte barr[] = str.getBytes();
System.out.println(Arrays.toString(barr));int result = 0;
for(int i = 0; i < barr.length; i++) {//System.out.print(barr[i]+" ");int ii = barr[i];char a = (char) ii;int no = Character.getNumericValue(a);result = result * 10 + no;System.out.println(result);}
System.out.println("result:"+result);}}

我编写了这个快速方法来将字符串输入解析为int或long。它比当前的JDK 11Integer.parseInt或Long.parseLong更快。虽然，你只要求int，但我也包含了long解析器。下面的代码解析器要求解析器的方法必须很小才能快速运行。测试代码下方有一个替代版本。替代版本非常快，它不依赖于类的大小。

此类检查溢出，您可以自定义代码以适应您的需求。使用我的方法，空字符串将产生0，但这是故意的。您可以更改它以适应您的案例或按原样使用。

这只是类中需要parseInt和parseLong的部分。请注意，这只处理基数10的数字。

int解析器的测试代码位于下面的代码下方。

/** Copyright 2019 Khang Hoang Nguyen* Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.* @author: Khang Hoang Nguyen - kevin@fai.host.**/final class faiNumber{private static final long[] longpow = {0L, 1L, 10L, 100L, 1000L, 10000L, 100000L, 1000000L, 10000000L, 100000000L, 1000000000L,10000000000L, 100000000000L, 1000000000000L, 10000000000000L, 100000000000000L,1000000000000000L, 10000000000000000L, 100000000000000000L, 1000000000000000000L,};
private static final int[] intpow = { 0, 1, 10, 100, 1000, 10000,100000, 1000000, 10000000, 100000000, 1000000000};
/*** parseLong(String str) parse a String into Long.* All errors throw by this method is NumberFormatException.* Better errors can be made to tailor to each use case.**/public static long parseLong(final String str) {final int length = str.length();if (length == 0)return 0L;
char c1 = str.charAt(0);int start;
if (c1 == '-' || c1 == '+') {if (length == 1)throw new NumberFormatException(String.format("Not a valid long value. Input '%s'.", str));start = 1;} else {start = 0;}
/** Note: if length > 19, possible scenario is to run through the string* to check whether the string contains only valid digits.* If the check had only valid digits then a negative sign meant underflow, else, overflow.*/if (length - start > 19)throw new NumberFormatException(String.format("Not a valid long value. Input '%s'.", str));
long c;long out = 0L;
for ( ; start < length; start++) {c = (str.charAt(start) ^ '0');if (c > 9L)throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );out += c * longpow[length - start];}
if (c1 == '-') {out = ~out + 1L;// If out > 0 number underflow(supposed to be negative).if (out > 0L)throw new NumberFormatException(String.format("Not a valid long value. Input '%s'.", str));return out;}// If out < 0 number overflow (supposed to be positive).if (out < 0L)throw new NumberFormatException(String.format("Not a valid long value. Input '%s'.", str));return out;}
/*** parseInt(String str) parse a string into an int.* return 0 if string is empty.**/public static int parseInt(final String str) {final int length = str.length();if (length == 0)return 0;
char c1 = str.charAt(0);int start;
if (c1 == '-' || c1 == '+') {if (length == 1)throw new NumberFormatException(String.format("Not a valid integer value. Input '%s'.", str));start = 1;} else {start = 0;}
int out = 0; int c;int runlen = length - start;
if (runlen > 9) {if (runlen > 10)throw new NumberFormatException(String.format("Not a valid integer value. Input: '%s'.", str));
c = (str.charAt(start) ^ '0'); // <- Any number from 0 - 255 ^ 48 will yield greater than 9 except 48 - 57if (c > 9)throw new NumberFormatException(String.format("Not a valid integer value. Input: '%s'.", str));if (c > 2)throw new NumberFormatException(String.format("Not a valid integer value. Input: '%s'.", str));out += c * intpow[length - start++];}
for ( ; start < length; start++) {c = (str.charAt(start) ^ '0');if (c > 9)throw new NumberFormatException(String.format("Not a valid integer value. Input: '%s'.", str));out += c * intpow[length - start];}
if (c1 == '-') {out = ~out + 1;if (out > 0)throw new NumberFormatException(String.format("Not a valid integer value. Input: '%s'.", str));return out;}
if (out < 0)throw new NumberFormatException(String.format("Not a valid integer value. Input: '%s'.", str));return out;}}

测试代码部分。这应该需要大约200秒左右。

// Int Number Parser Test;long start = System.currentTimeMillis();System.out.println("INT PARSER TEST");for (int i = Integer.MIN_VALUE; i != Integer.MAX_VALUE; i++){if (faiNumber.parseInt(""+i) != i)System.out.println("Wrong");if (i == 0)System.out.println("HalfWay Done");}
if (faiNumber.parseInt("" + Integer.MAX_VALUE) != Integer.MAX_VALUE)System.out.println("Wrong");long end = System.currentTimeMillis();long result = (end - start);System.out.println(result);// INT PARSER END */

另一种方法也非常快。请注意，没有使用int pow数组，而是通过位移位乘以10的数学优化。

public static int parseInt(final String str) {final int length = str.length();if (length == 0)return 0;
char c1 = str.charAt(0);int start;
if (c1 == '-' || c1 == '+') {if (length == 1)throw new NumberFormatException(String.format("Not a valid integer value. Input '%s'.", str));start = 1;} else {start = 0;}
int out = 0;int c;while (start < length && str.charAt(start) == '0')start++; // <-- This to disregard leading 0. It can be// removed if you know exactly your source// does not have leading zeroes.int runlen = length - start;
if (runlen > 9) {if (runlen > 10)throw new NumberFormatException(String.format("Not a valid integer value. Input: '%s'.", str));
c = (str.charAt(start++) ^ '0');  // <- Any number from 0 - 255 ^ 48 will yield greater than 9 except 48 - 57if (c > 9)throw new NumberFormatException(String.format("Not a valid integer value. Input: '%s'.", str));if (c > 2)throw new NumberFormatException(String.format("Not a valid integer value. Input: '%s'.", str));out = (out << 1) + (out << 3) + c; // <- Alternatively this can just be out = c or c above can just be out;}
for ( ; start < length; start++) {c = (str.charAt(start) ^ '0');if (c > 9)throw new NumberFormatException(String.format("Not a valid integer value. Input: '%s'.", str));out = (out << 1) + (out << 3) + c;}
if (c1 == '-') {out = ~out + 1;if (out > 0)throw new NumberFormatException(String.format("Not a valid integer value. Input: '%s'.", str));return out;}
if (out < 0)throw new NumberFormatException(String.format("Not a valid integer value. Input: '%s'.", str));return out;}

将String转换为Int的一些方法如下：

1. 您可以使用Integer.parseInt()：

   String test = "4568";int new = Integer.parseInt(test);

2. Also you can use Integer.valueOf():

   String test = "4568";int new = Integer.valueOf(test);

自定义算法：

public static int toInt(String value) {int output = 0;boolean isFirstCharacter = true;boolean isNegativeNumber = false;byte bytes[] = value.getBytes();for (int i = 0; i < bytes.length; i++) {char c = (char) bytes[i];if (!Character.isDigit(c)) {isNegativeNumber = (c == '-');if (!(isFirstCharacter && (isNegativeNumber || c == '+'))) {throw new NumberFormatException("For input string \"" + value + "\"");}} else {int number = Character.getNumericValue(c);output = output * 10 + number;}isFirstCharacter = false;}if (isNegativeNumber)output *= -1;return output;}

另一种解决方案：

（使用字符串字符方法而不是将字符串转换为字节数组）

public static int toInt(String value) {int output = 0;boolean isFirstCharacter = true;boolean isNegativeNumber = false;for (int i = 0; i < value.length(); i++) {char c = value.charAt(i);if (!Character.isDigit(c)) {isNegativeNumber = (c == '-');if (!(isFirstCharacter && (isNegativeNumber || c == '+'))) {throw new NumberFormatException("For input string \"" + value + "\"");}} else {int number = Character.getNumericValue(c);output = output * 10 + number;}isFirstCharacter = false;}if (isNegativeNumber)output *= -1;return output;}

示例：

int number1 = toInt("20");int number2 = toInt("-20");int number3 = toInt("+20");System.out.println("Numbers = " + number1 + ", " + number2 + ", " + number3);
try {toInt("20 Hadi");} catch (NumberFormatException e) {System.out.println("Error: " + e.getMessage());}

当我在GitHub上写作时：

public class StringToInteger {public static void main(String[] args) {assert parseInt("123") == Integer.parseInt("123");assert parseInt("-123") == Integer.parseInt("-123");assert parseInt("0123") == Integer.parseInt("0123");assert parseInt("+123") == Integer.parseInt("+123");}
/*** Parse a string to integer** @param s the string* @return the integer value represented by the argument in decimal.* @throws NumberFormatException if the {@code string} does not contain a parsable integer.*/public static int parseInt(String s) {if (s == null) {throw new NumberFormatException("null");}boolean isNegative = s.charAt(0) == '-';boolean isPositive = s.charAt(0) == '+';int number = 0;for (int i = isNegative ? 1 : isPositive ? 1 : 0, length = s.length(); i < length; ++i) {if (!Character.isDigit(s.charAt(i))) {throw new NumberFormatException("s=" + s);}number = number * 10 + s.charAt(i) - '0';}return isNegative ? -number : number;}}

通过使用此方法，您可以避免错误。

String myString = "1234";int myInt;if(Integer.parseInt(myString), out myInt){};

执行此操作的两种主要方法是使用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

将字符串int值转换为整数数据类型值有不同的方法。您需要处理字符串值问题的NumberFormatException。

1. Integer.parse

    foo = Integer.parseInt(myString);

2. Integer.value

    foo = Integer.valueOf(myString);

3. 使用Java8可选API

    foo = Optional.ofNullable(myString).map(Integer::parseInt).get();

你可以有自己的实现，比如：

public class NumericStringToInt {
public static void main(String[] args) {String str = "123459";
int num = stringToNumber(str);System.out.println("Number of " + str + " is: " + num);}
private static int stringToNumber(String str) {
int num = 0;int i = 0;while (i < str.length()) {char ch = str.charAt(i);if (ch < 48 || ch > 57)throw new NumberFormatException("" + ch);num = num * 10 + Character.getNumericValue(ch);i++;}return num;}}

这可以工作，

Integer.parseInt(yourString);

除了所有这些答案之外，我发现了一种新的方法，尽管它在内部使用Integer.parseInt()。

通过使用

import javafx.util.converter.IntegerStringConverter;
new IntegerStringConverter().fromString("1234").intValue()

或

new IntegerStringConverter().fromString("1234")

虽然随着新对象的创建，它的成本有点高。

只需浏览javafx.util.StringConverter<T>类。它有助于将任何包装类值转换为字符串，反之亦然。

您可以使用Integer.parseInt（str）。

例如：

String str = "2";
int num = Intger.parseInt(str);

如果字符串具有无效或非数字字符，则需要处理NumberFormatException。

使用Java11，有几种方法可以将int类型转换为String类型：

1）Integer.parseInt（）

String str = "1234";int result = Integer.parseInt(str);

2）Integer.valueOf（）

String str = "1234";int result = Integer.valueOf(str).intValue();

3）整数构造函数

  String str = "1234";Integer result = new Integer(str);

4）Integer.decode

String str = "1234";int result = Integer.decode(str);

如果需要原语，请使用parseIntInteger.valueOf（）

对于在这里结束的Android开发人员，这些是静态编程语言的各种解决方案：

// Throws exception if number has bad formval result1 = "1234".toInt()

// Will be null if number has bad formval result2 = "1234".runCatching(String::toInt).getOrNull()

// Will be the given default if number has bad formval result3 = "1234".runCatching(String::toInt).getOrDefault(0)

// Will be return of the else block if number has bad formval result4 = "1234".runCatching(String::toInt).getOrElse {// some code// return an Int}