如何在Java中将String转换为int？
我的字符串只包含数字，我想返回它代表的数字。
例如，给定字符串"1234"，结果应为数字1234。
答案 0 :(得分：3849)
String myString = "1234";
int foo = Integer.parseInt(myString);
如果你看Java Documentation，你会注意到“catch”是这个函数可以抛出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)
答案 1 :(得分：638)
例如，有两种方法：
Integer x = Integer.valueOf(str);
// or
int y = Integer.parseInt(str);
这些方法之间存在细微差别：
valueOf返回java.lang.Integer parseInt返回原始int。 所有情况都是如此：Short.valueOf / parseShort，Long.valueOf / parseLong等。
答案 2 :(得分：233)
嗯，需要考虑的一个非常重要的一点是，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.
}
在尝试从split参数中获取整数值或动态解析某些内容时，处理此异常非常重要。
答案 3 :(得分：81)
手动执行：
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;
}
答案 4 :(得分：42)
目前我正在为大学做作业，在那里我不能使用某些表达式，例如上面的表达式，通过查看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中的后者（lastdigit）除以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 "()"
你去吧。考虑到以下限制，您将一个数字串（在本例中为两位数）转换为由这两个数字组成的整数：
答案 5 :(得分：42)
另一种解决方案是使用Apache Commons' NumberUtils：
int num = NumberUtils.toInt("1234");
Apache实用程序很好，因为如果字符串是无效的数字格式，则始终返回0。因此保存try catch块。
答案 6 :(得分：33)
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();
答案 7 :(得分：26)
每当给定String不包含Integer的可能性最小时，您必须处理这种特殊情况。遗憾的是，标准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 1234
System.out.println(tryParseInteger("1234").orElse(-1));
// prints -1
System.out.println(tryParseInteger("foobar").orElse(-1));
虽然这仍然在内部使用流控制的异常，但使用代码变得非常干净。
答案 8 :(得分：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对象，所有其他方法 - primitive int。
commons-lang3中的最后两个方法和关于转换here的大文章。
答案 9 :(得分：23)
将字符串转换为int比仅转换数字更复杂。您已经考虑过以下问题：
答案 10 :(得分：22)
我们可以使用parseInt(String str)包装类的Integer方法将String值转换为整数值。
例如：
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进行转换：
String strValue = "12345";
Integer intValue = NumberUtils.toInt(strValue);
答案 11 :(得分：19)
使用Integer.parseInt(yourString)
请记住以下事项：
Integer.parseInt("-1"); //确定
Integer.parseInt("+1"); //确定
Integer.parseInt(" 1"); //确定
Integer.parseInt("2147483648"); //例外（空格）
Integer.parseInt("1.1"); //异常（整数仅限于maximum value 2,147,483,647）
Integer.parseInt(""); //例外（。或，或其他不允许的内容）
_.toString(null);
// => ''
_.toString(-0);
// => '-0'
_.toString([1, 2, 3]);
// => '1,2,3'
//例外（不是0或其他）
只有一种类型的例外：NumberFormatException
答案 12 :(得分：19)
我有一个解决方案，但我不知道它有多有效。但它运作良好，我认为你可以改进它。另一方面，我使用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));
}
}
}
答案 13 :(得分：17)
只是为了好玩：您可以使用Java 8 Optional将String转换为Integer：
String str = "123";
Integer value = Optional.of(str).map(Integer::valueOf).get();
// Will return the integer value of the specified string, or it
// will throw an NPE when str is null.
value = Optional.ofNullable(str).map(Integer::valueOf).orElse(-1);
// Will do the same as the code above, except it will return -1
// when srt is null, instead of throwing an NPE.
此处我们只合并Integer.valueOf和Optinal。可能存在这种情况有用的情况 - 例如，当您想要避免空检查时。 Pre Java 8代码如下所示：
Integer value = (str == null) ? -1 : Integer.parseInt(str);
答案 14 :(得分：16)
Guava有tryParse(String)，如果无法解析字符串，则返回null，例如：
Integer fooInt = Ints.tryParse(fooString);
if (fooInt != null) {
...
}
答案 15 :(得分：13)
除了上述答案之外，我还想添加几个功能。这些是您使用它们时的结果：
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;
}
答案 16 :(得分：13)
您也可以先删除所有非数字字符然后解析int：
string mystr = mystr.replaceAll( "[^\\d]", "" );
int number= Integer.parseInt(mystr);
但请注意，这仅适用于非负数。
答案 17 :(得分：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;
}
使用字符串常量进行比较或任何类型的计算总是一个好主意，因为常量永远不会返回空值。
答案 18 :(得分：9)
如前所述，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;
答案 19 :(得分：9)
您可以使用new Scanner("1244").nextInt()。或者询问是否存在int：new Scanner("1244").hasNextInt()
答案 20 :(得分：9)
在编程竞赛中，你确信数字永远是一个有效的整数，那么你可以编写自己的方法来解析输入。这将跳过所有与验证相关的代码（因为您不需要任何相关代码）并且效率会更高。
对于有效的正整数：
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()。
答案 21 :(得分：7)
int foo=Integer.parseInt("1234");
确保字符串中没有非数字数据。
答案 22 :(得分：7)
对于普通字符串，您可以使用：
@ManyToMany对于String builder和String buffer，您可以使用：
int number = Integer.parseInt("1234");
答案 23 :(得分：7)
您可以试试这个：
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
答案 24 :(得分：6)
我们走了
String str="1234";
int number = Integer.parseInt(str);
print number;//1234
答案 25 :(得分：6)
我有点意外，没有人提及将String作为参数的Integer构造函数。
所以，这是：
String myString = "1234";
int i1 = new Integer(myString);
当然，构造函数将返回类型Integer，并且取消装箱操作会将值转换为int。
提及的重要性
此构造函数调用parseInt方法。
public Integer(String var1) throws NumberFormatException {
this.value = parseInt(var1, 10);
}
答案 26 :(得分：5)
使用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);
}
}
答案 27 :(得分：4)
这是完整程序，所有条件均为正，否定而不使用库
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;
}
}
答案 28 :(得分：4)
可以通过7种方式完成：
(fn [& args]) 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答案 29 :(得分：3)
请注意，如果字符串为null，则调用：
int i = Integer.parseInt(null);
引发NumberFormatException，而不是NullPointerException。
答案 30 :(得分：3)
您可以使用以下任何一种方式：
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) 答案 31 :(得分：2)
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);
}
}
答案 32 :(得分：2)
执行此操作的两种主要方法是使用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()返回一个int，而valueOf()返回一个Integer
答案 33 :(得分：1)
公共静态int parseInt（String s）引发NumberFormatException
您可以使用Integer.parseInt()将String转换为int。
将字符串20转换为原始整数。
String n = "20";
int r = Integer.parseInt(n);//returns a primitive int
System.out.println(r);
输出20
如果字符串不包含可分析的整数。它会抛出NumberFormatException
String n = "20I";// throwns NumberFormatException
int r = Integer.parseInt(n);
System.out.println(r);
公共静态整数valueOf（String s）引发NumberFormatException
您可以使用Integer.valueOf()，在这种情况下，它将返回一个Integer对象。
String n = "20";
Integer r = Integer.valueOf(n); //returns a new Integer() object.
System.out.println(r);
输出20
答案 34 :(得分：1)
这可以工作，
repo答案 35 :(得分：1)
Integer.parseInt(myString);-使用包装器类
答案 36 :(得分：1)
通过使用这种方法，您可以避免错误。
String myString = "1234";
int myInt;
if(Integer.parseInt(myString), out myInt){};
答案 37 :(得分：0)
你可以使用Integer.parseInt(str)
例如：
String str = "2";
int num = Intger.parseInt(str);
如果字符串包含无效或非数字字符，您需要处理 NumberFormatException。
答案 38 :(得分：0)
请使用 NumberUtils 从字符串中解析整数。
这是示例代码。
NumberUtils.toInt("00450");
NumberUtils.toInt("45464646545645400000");
NumberUtils.toInt("45464646545645400000", 0); // Where 0 is the default value.
output:
450
0
0
答案 39 :(得分：0)
除了所有这些答案，我发现了一种新方法，尽管它在内部使用Integer.parseInt()，
通过使用
import javafx.util.converter.IntegerStringConverter;
new IntegerStringConverter().fromString("1234").intValue()
或
new IntegerStringConverter().fromString("1234")
尽管创建新对象会花费一些钱，但我只是想在学习新方法时添加。
只需遍历javafx.util.StringConverter<T>类，它有助于将任何包装器类的值转换为字符串，反之亦然。
答案 40 :(得分：0)
您可以为此使用自己的实现，
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;
}
}
答案 41 :(得分：0)
有多种将字符串int值转换为Integer数据类型值的方法。您需要处理NumberFormatException来解决字符串值问题。
Integer.parseInt
foo = Integer.parseInt(myString);
Integer.valueOf
foo = Integer.valueOf(myString);
使用Java 8可选API
foo = Optional.of(myString).map(Integer::parseInt).get();
答案 42 :(得分：0)
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;
}
}
答案 43 :(得分：0)
使用方法：Integer.parseInt(String s)
String s = "123";
int n = Integer.parseInt(s);
答案 44 :(得分：0)
自定义算法：
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;
}
另一种解决方案： （使用字符串 charAt 方法，而不是将字符串转换为字节数组）：
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());
}
答案 45 :(得分：0)
使用此方法：
public int ConvertStringToInt(String number) {
int num = 0;
try {
int newNumber = Integer.ParseInt(number);
num = newNumber;
} catch(Exception ex) {
num = 0;
Log.i("Console",ex.toString);
}
return num;
}
答案 46 :(得分：0)
将String转换为Int的一些方法如下：
您可以使用Integer.parseInt()：
String test = "4568";
int new = Integer.parseInt(test);
您还可以使用Integer.valueOf()：
String test = "4568";
int new =Integer.parseInt(test);
答案 47 :(得分：0)
我编写了此快速方法，将输入的字符串解析为int或long。它比当前的JDK 11 Integer.parseInt或Long.parseLong更快。虽然，您只要求提供整数，但我还提供了长解析器。下面的代码解析器要求解析器的方法必须很小，才能快速运行。替代版本在测试代码下方。替代版本非常快，并且与类的大小无关。
此类检查溢出，您可以自定义代码以适应您的需求。使用我的方法，空字符串将产生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 - 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, 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;
}
答案 48 :(得分：0)
您可以使用 Integer.parseInt() 方法
示例：
String strNumber = "5790";
int extractNumber = Integer.parseInt(strNumber);
//Result will be --5790
System.out.println(extractNumber);
答案 49 :(得分：0)
使用Java Integer类的parseInt方法将字符串转换为整数。 parseInt方法是将String转换为int类型，如果无法将字符串转换为int类型则抛出NumberFormatException。
忽略它可能引发的异常，请使用以下方法：
int i = Integer.parseInt(myString);
如果由变量myString表示的String是一个有效的整数，例如“1234”, “200”, “1”,，它将被转换为Java int。如果由于任何原因失败，更改可能会引发NumberFormatException，因此代码应稍长一些以解决此问题。
例如Java String到int的转换方法，控制可能的NumberFormatException
public class JavaStringToIntExample
{
public static void main (String[] args)
{
// String s = "test"; // use this if you want to test the exception below
String s = "1234";
try
{
// the String to int conversion happens here
int i = Integer.parseInt(s.trim());
// print out the value after the conversion
System.out.println("int i = " + i);
}
catch (NumberFormatException nfe)
{
System.out.println("NumberFormatException: " + nfe.getMessage());
}
}
}
如果更改尝试失败（以防万一，如果您可以尝试将Java String测试转换为int），则Integer parseInt进程将抛出NumberFormatException，您必须在尝试中进行处理/ catch块。
答案 50 :(得分：0)
使用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();
}
}
答案 51 :(得分：0)
使用Integer.parseInt()，这将有助于您将字符串值解析为int。
示例：
String str = "2017";
int i = Integer.parseInt(str);
System.out.println(i);
输出： 2017
答案 52 :(得分：-1)
您可以使用他们的方式：
String stringNumber = "0123456789";
1-使用parseInt
try {
int number = Integer.parseInt(stringNumber);
}catch (NumberFormatException e){
// Handel exception, mybe has space or alphabet
}
2-使用valueOf
try {
int number = Integer.valueOf(stringNumber);
}catch (NumberFormatException e){
// Handel exception, mybe has space or alphabet
}
答案 53 :(得分：-5)
或者，您可以使用Integer.valueOf()。它将返回Integer个对象。
String numberStringFormat = "10";
Integer resultIntFormat = Integer.valueOf(numberStringFormat);
LOG.info("result:"+resultIntFormat);
输出：10