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 库中的方法，该方法与 Java 8 的 相结合，提供了一种强大而简洁的方法将字符串转换为 int：IntsOptional

import com.google.common.primitives.Ints;

int foo = Optional.ofNullable(myString)
 .map(Ints::tryParse)
 .orElse(0)

例如，这里有两种方法：

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

这些方法之间略有不同：

• valueOf返回java.lang.Integer
• parseInt返回原始 。int

这同样适用于所有情况：/、/ 等。Short.valueOfparseShortLong.valueOfparseLong

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

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

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

手动执行：

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

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

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

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

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

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

另一个限制是我不能使用重复循环，因此，也不能使用循环（本来是完美的）。这限制了我们，但话又说回来，这就是目标。由于我只需要两位数（取最后两位数），因此一个简单的方法就解决了：forcharAt

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

我有一个解决方案，但我不知道它的效果如何。但它运行良好，我认为您可以改进它。另一方面，我用 JUnit 做了几个测试，步骤正确。我附上了功能和测试：

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

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

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

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

Apache NumberUtils API 版本 3.4

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

例如：

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

该类还提供了以下方法：IntegervalueOf(String str)

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

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

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

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

如果你想得到而不是你可以使用：intInteger

1. 拆 箱：

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

2. intValue():

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

每当给定的 String 不包含 Integer 的可能性很小时，您就必须处理这种特殊情况。可悲的是，标准的 Java 方法和 throw a 来表示这种特殊情况。因此，您必须使用异常进行流控制，这通常被认为是糟糕的编码风格。Integer::parseIntInteger::valueOfNumberFormatException

在我看来，这种特殊情况应该通过返回一个空的.由于 Java 不提供这样的方法，我使用以下包装器：Optional<Integer>

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

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

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

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;

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

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

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

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

对于普通 ，您可以使用：String

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

对于 和 ，您可以使用：StringBuilderStringBuffer

Integer.parseInt(myBuilderOrBuffer.toString());

您可以使用 .或者询问是否存在 int：new Scanner("1244").nextInt()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. 对于正整数和负整数：

        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. 如果您期望在这些数字之前或之后有空格， 然后确保在进一步处理之前做一个。str = str.trim()

执行此操作的方法：

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生成一个对象，所有其他方法生成一个原始 int。Integer

最后两种方法来自 commons-lang3 和一篇关于转换的大文章。

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

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

所以，这里是：

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

Java 8 - Integer（String）。

当然，构造函数将返回 type ，并且拆箱操作将值转换为 。Integerint

---

注意 1：需要注意的是：此构造函数调用该方法。parseInt

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

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

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 11 Integer.parseInt 或 Long.parseLong 更快。虽然，你只要求 int，但我也包括了长解析器。下面的代码解析器要求解析器的方法必须很小，以便快速运行。测试代码下方是替代版本。替代版本非常快，它不依赖于类的大小。

此类检查溢出，您可以自定义代码以适应您的需求。空字符串将使用我的方法产生 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 - [email protected].
 **/
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 - 57
            if (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 - 57
        if (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;
}

正如我在 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;
    }
}

执行此操作的两种主要方法是使用类的方法和方法。valueOf()parseInt()Integer

假设你得到一个这样的字符串

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

有多种方法可以将字符串 int 值转换为 Integer 数据类型值。您需要处理字符串值问题的 NumberFormatException。

1. Integer.parseInt

    foo = Integer.parseInt(myString);
   

2. Integer.valueOf

    foo = Integer.valueOf(myString);
   

3. 使用 Java 8 可选 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()

通过使用

import javafx.util.converter.IntegerStringConverter;

new IntegerStringConverter().fromString("1234").intValue()

或

new IntegerStringConverter().fromString("1234")

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

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

在 Java 11 中，有几种方法可以将 an 转换为类型：intString

1） Integer.parseInt（）

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

2）整数.valueOf（）

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

3） Integer 构造函数

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

4） 整数解码

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

对于最终来到这里的 Android 开发人员来说，这些是 Kotlin 的各种解决方案：

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

// Will be null if number has bad form
val result2 = "1234".toIntOrNull()

// Will be the given default if number has bad form
val result3 = "1234"
    .toIntOrNull() ?: -1

// Will be return of the run block if number has bad form
val result4 = "1234"
    .toIntOrNull()
    ?: run {
        // some code
        // return an Int
    }

// Ignores any none-digit character in string
val result5 = "12abc34"
    .filter { it.isDigit() }
    .joinToString(separator="")
    .toIntOrNull()

This function accepts any param types as input

• then try to convert it toString()
• then extract integer via regex
• and safe convert string to int

    public int toInt(Object o) {

        // input param is an integer :|
        if (o instanceof Integer)
            return (int) o;

        // input param is (null) so return zero
        if (o == null)
            return 0;

        // input param is boolean, so false = 0 \ true = 1
        if (o instanceof Boolean)
            return Boolean.TRUE.equals(o) ? 1 : 0;

        // convert object to string
        String str = "0";
        if (o instanceof String) {
            str = (String) o;
        } else { 
            try {
                str = o.toString();
            } catch (Exception e) {}
        }

        // return zero if the string is empty
        if (str == "")
            return 0;

        // detect and export numbers from the string
        try {
            Pattern p = Pattern.compile("\\d+");
            Matcher m = p.matcher(str);
            if ( m.find() ) {
                str = m.group(0);
            } else { // string not contains any numbers
                str = "0";
            }
        } catch (Exception e) {
            str = "0";
        }
        
        // java stores integers in 32-bit, so can not store more than 10 digits
        if (str.length() > 19) {
            str = str.substring(0, 19);
        }

        // convert string to integer
        int result = 0;
        try {
            result = Integer.parseInt(str);
        } catch (Exception e) {}

        return result;
    }

您可以更改

catch (Exception e) {}

自

catch (Exception e) { e.printStackTrace(); }

显示有关 logcat 中错误的更详细数据

可以处理以下输入：

• false
• ""
• "00004"
• " 51"
• "74.6ab.cd"
• "foo 654 bar"

警告

此函数将 （string） 更改为 （int）"ab2cd3ef4"234