可以通过七种方式实现：

import com.google.common.primitives.Ints;
import org.apache.commons.lang.math.NumberUtils;

String number = "999";
``` `Ints.tryParse` :
int result=int.tryparse（数字）； `NumberUtils.createInteger` :
integer result=numberutils.createinteger（数字）； `NumberUtils.toInt` :
int result=numberutils.toint（数字）； `Integer.valueOf` :
整数结果=integer.valueof（number）； `Integer.parseInt` :
int result=integer.parseint（数字）； `Integer.decode` :
int result=integer.decode（数字）； `Integer.parseUnsignedInt` :
int result=integer.parseunsignedint（数字）；

方法： 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) valueof生成一个integer对象，所有其他方法生成一个基元int。
最后两种方法来自commons-lang3和一篇关于转换的大文章。

只要有一点点可能给定的字符串不包含整数，就必须处理这种特殊情况。遗憾的是，标准的java方法 Integer::parseInt 以及 Integer::valueOf 扔一个 NumberFormatException 以表明这个特殊情况。因此，您必须为流控制使用异常，这通常被认为是糟糕的编码风格。
在我看来，这种特殊情况应该通过返回一个空的 Optional<Integer> . 由于java不提供这种方法，因此我使用以下 Package 器：

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 mystr = mystr.replaceAll("[^\\d]", "");
int number = Integer.parseInt(mystr);

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

在编程竞赛中，如果您确信数字总是一个有效的整数，那么您可以编写自己的方法来解析输入。这将跳过所有与验证相关的代码（因为您不需要这些代码中的任何一个），而且效率会更高一些。
对于有效的正整数：

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() 在进一步处理之前。

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

例如，有两种方法：

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

这些方法略有不同： valueOf 返回的新示例或缓存示例
java.lang.Integer parseInt 返回原语 int .
所有情况都是如此： Short.valueOf / parseShort , Long.valueOf / parseLong 等等。

目前我正在做一个大学作业，在那里我不能使用某些表达式，比如上面的表达式，通过查看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，没有任何数学运算，我们可以做。
我们把后者（最后一位数）除以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这样的“神奇”表达式

您也可以使用此代码，但需要注意一些事项。
选项#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;
}

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

googleguava有tryparse（string），它返回 null 如果无法解析字符串，例如：

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

我们开始吧

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

使用 Integer.parseInt(yourString) .
记住以下几点： Integer.parseInt("1"); //好的 Integer.parseInt("-1"); //好的 Integer.parseInt("+1"); //好的 Integer.parseInt(" 1"); //异常（空白） Integer.parseInt("2147483648"); //异常（整数的最大值限制为2147483647） Integer.parseInt("1.1"); //异常（。或任何不允许的） Integer.parseInt(""); //异常（不是0或其他）
只有一种类型的异常： NumberFormatException

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

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

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

如果您查看java文档，您会注意到“catch”是这个函数可以抛出 NumberFormatException ，当然你必须处理：

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

（此处理将格式错误的数字默认为 0 ，但如果您愿意，您可以做其他事情。）
或者，您可以使用 Ints 方法，它与Java8的 Optional ，提供了一种将字符串转换为int的强大而简洁的方法：

import com.google.common.primitives.Ints;

int foo = Optional.ofNullable(myString)
 .map(Ints::tryParse)
 .orElse(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);
    }
 }