How can I convert a String to an int in Java?
如何将字符串转换成Java中的int类型?
My String contains only numbers, and I want to return the number it represents.
我的字符串只包含数字，我要返回它表示的数字。
For example, given the string "1234" the result should be the number 1234.
例如，给定字符串“1234”，结果应该是数字1234。
30 个解决方案
#1
3420
String myString = "1234";
int foo = Integer.parseInt(myString);
See the Java Documentation for more information.
有关更多信息，请参见Java文档。
#2
561
For example, here are two ways:
例如，这里有两种方法:
Integer x = Integer.valueOf(str);
// or
int y = Integer.parseInt(str);
There is a slight difference between these methods:
这些方法之间有细微的差别:
-
valueOfreturns a new or cached instance ofjava.lang.Integer - valueOf返回一个新的或缓存的java.lang.Integer实例。
-
parseIntreturns primitiveint. - 方法用于返回原始int。
The same is for all cases: Short.valueOf/parseShort, Long.valueOf/parseLong, etc.
所有的情况都是一样的:短。返回对象的值/ parseShort,长。返回对象的值/ parseLong等等。
#3
204
Well, a very important point to consider is that the Integer parser throws NumberFormatException as stated in Javadoc.
很重要的一点是，整数解析器会在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.
}
It is important to handle this exception when trying to get integer values from split arguments or dynamically parsing something.
在尝试从拆分参数或动态解析某些内容获取整数值时，处理这个异常是很重要的。
#4
70
Do it manually:
手动启动:
#5
34
Currently I'm doing an assignment for college, where I can't use certain expressions, such as the ones above, and by looking at the ASCII table, I managed to do it. It's a far more complex code, but it could help others that are restricted like I was.
目前我正在为大学做作业，在那里我不能使用某些表达式，比如上面的表达式，通过查看ASCII表，我成功地做到了这一点。这是一个复杂得多的代码，但它可以帮助像我这样受到限制的其他人。
The first thing to do is to receive the input, in this case, a string of digits; I'll call it String number, and in this case, I'll exemplify it using the number 12, therefore String number = "12";
首先要做的是接收输入，在这个例子中，是一串数字;我将它命名为String number，在这种情况下，我将用number 12来举例说明它，因此String number = "12";
Another limitation was the fact that I couldn't use repetitive cycles, therefore, a for cycle (which would have been perfect) can't be used either. This limits us a bit, but then again, that's the goal. Since I only needed two digits (taking the last two digits), a simple charAtsolved it:
另一个限制是，我不能使用重复周期，因此，for循环(本来应该是完美的)也不能使用。这限制了我们一点，但这是我们的目标。因为我只需要两个数字(最后两个数字)，一个简单的查图解决了:
// 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);
Having the codes, we just need to look up at the table, and make the necessary adjustments:
有了这些代码，我们只需要查阅一下表格，做出必要的调整:
double semilastdigit = semilastdigitASCII - 48; //A quick look, and -48 is the key
double lastdigit = lastdigitASCII - 48;
Now, why double? Well, because of a really "weird" step. Currently we have two doubles, 1 and 2, but we need to turn it into 12, there isn't any mathematic operation that we can do.
为什么双?因为这是一个很奇怪的步骤。现在我们有两个双打，1和2，但是我们需要把它变成12，没有任何数学运算我们可以做。
We're dividing the latter (lastdigit) by 10 in the fashion 2/10 = 0.2 (hence why double) like this:
我们将后者(lastdigit)除以10，在时尚2/10 = 0.2(因此为什么是double):
lastdigit = lastdigit/10;
This is merely playing with numbers. We were turning the last digit into a decimal. But now, look at what happens:
这只是在玩弄数字。我们把最后一位数变成了小数。但是现在，看看会发生什么:
double jointdigits = semilastdigit + lastdigit; // 1.0 + 0.2 = 1.2
Without getting too into the math, we're simply isolating units the digits of a number. You see, since we only consider 0-9, dividing by a multiple of 10 is like creating a "box" where you store it (think back at when your first grade teacher explained you what a unit and a hundred were). So:
如果不考虑数学问题，我们只是简单地将一个数字的数字隔离开来。你看，因为我们只考虑0-9，除以10的倍数就像创建一个“盒子”，你把它储存起来(回想一下你的一年级老师给你解释了一个单位和100个是什么)。所以:
int finalnumber = (int) (jointdigits*10); // Be sure to use parentheses "()"
And there you go. You turned a String of digits (in this case, two digits), into an integer composed of those two digits, considering the following limitations:
你去。您将一串数字(在本例中为两个数字)转换为由这两个数字组成的整数，考虑以下限制:
- No repetitive cycles
- 没有重复的周期
- No "Magic" Expressions such as parseInt
- 没有像parseInt这样的“魔法”表达式。
#6
32
An alternate solution is to use Apache Commons' NumberUtils:
另一种解决方案是使用Apache Commons的NumberUtils:
int num = NumberUtils.toInt("1234");
The Apache utility is nice because if the string is an invalid number format then 0 is always returned. Hence saving you the try catch block.
Apache实用程序很好，因为如果字符串是无效的数字格式，那么总是返回0。因此，为您节省了try catch块。
Apache NumberUtils API Version 3.4
Apache NumberUtils API版本3.4。
#7
26
Integer.decode
You can also use public static Integer decode(String nm) throws NumberFormatException.
您还可以使用公共静态整数解码(String nm)抛出NumberFormatException。
It also works for base 8 and 16:
它也适用于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
If you want to get int instead of Integer you can use:
如果你想要整数而不是整数，你可以使用:
-
Unboxing:
拆箱:
int val = Integer.decode("12"); -
intValue():intValue():
Integer.decode("12").intValue();
#8
19
Converting a string to an int is more complicated than just convertig a number. You have think about the following issues:
将字符串转换为整数比仅仅转换一个数字要复杂得多。你可以考虑以下问题:
- Does the string only contains numbers 0-9?
- 字符串是否只包含数字0-9?
- What's up with -/+ before or after the string? Is that possible (referring to accounting numbers)?
- 在字符串之前或之后是什么?这可能吗(指会计数字)?
- What's up with MAX_-/MIN_INFINITY? What will happen if the string is 99999999999999999999? Can the machine treat this string as an int?
- 与MAX_ / MIN_INFINITY是什么?如果字符串是9999999999999999，会发生什么?机器能把这条线当作整数吗?
#9
18
Whenever there is the slightest possibility that the given String does not contain an Integer, you have to handle this special case. Sadly, the standard Java methods Integer::parseInt and Integer::valueOf throw a NumberFormatException to signal this special case. Thus, you have to use exceptions for flow control, which is generally considered bad coding style.
无论何时，只要给定的字符串不包含整数，就必须处理这个特殊的情况。遗憾的是，标准的Java方法Integer::parseInt和Integer::valueOf抛出NumberFormatException来表示这个特殊的情况。因此，您必须使用流控制的异常，这通常被认为是糟糕的编码风格。
In my opinion, this special case should be handled by returning an Optional<Integer>. Since Java does not offer such a method, I use the following wrapper:
在我看来，这个特殊的情况应该通过返回一个可选的 <整数> 来处理。由于Java不提供这样的方法，所以我使用以下包装器:
private Optional<Integer> tryParseInteger(String string) {
try {
return Optional.of(Integer.valueOf(string));
} catch (NumberFormatException e) {
return Optional.empty();
}
}
Usage:
用法:
// prints 1234
System.out.println(tryParseInteger("1234").orElse(-1));
// prints -1
System.out.println(tryParseInteger("foobar").orElse(-1));
While this is still using exceptions for flow control internally, the usage code becomes very clean.
虽然这仍然在内部使用流控制的异常，但是使用代码变得非常干净。
#10
17
We can use the parseInt(String str) method of the Integer wrapper class for converting a String value to an integer value.
我们可以使用整数包装器类的parseInt(String str)方法将字符串值转换为整数值。
For example:
例如:
String strValue = "12345";
Integer intValue = Integer.parseInt(strVal);
The Integer class also provides the valueOf(String str) method:
整数类还提供了valueOf(String str)方法:
String strValue = "12345";
Integer intValue = Integer.valueOf(strValue);
We can also use toInt(String strValue) of NumberUtils Utility Class for the conversion:
我们还可以使用NumberUtils实用程序类的toInt(String strValue)进行转换:
String strValue = "12345";
Integer intValue = NumberUtils.toInt(strValue);
#11
15
I'm have a solution, but I do not know how effective it is. But it works well, and I think you could improve it. On the other hand, I did a couple of tests with JUnit which step correctly. I attached the function and testing:
我有一个解决方案，但我不知道它有多有效。但是它很有效，我认为你可以改进它。另一方面，我用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;
}
Testing with JUnit:
与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));
}
}
}
#12
11
Use Integer.parseInt(yourString)
使用Integer.parseInt(yourString)
Remember following things:
记住以下事情:
Integer.parseInt("1"); // ok
Integer.parseInt(" 1 ");/ /好吧
Integer.parseInt("-1"); // ok
Integer.parseInt(" 1 ");/ /好吧
Integer.parseInt("+1"); // ok
Integer.parseInt(“+ 1”);/ /好吧
Integer.parseInt(" 1"); // Exception (blank space)
整数。方法(" 1 ");/ /异常(空白)
Integer.parseInt("2147483648"); // Exception (Integer is limited to a maximum value of 2,147,483,647)
Integer.parseInt(“2147483648”);//例外(整数限为2,147,483,647)
Integer.parseInt("1.1"); // Exception (. or , or whatever is not allowed)
Integer.parseInt(" 1.1 ");/ /异常(。或者，或者任何不允许的事情)
Integer.parseInt(""); // Exception (not 0 or something)
Integer.parseInt(" ");//异常(非0或其他)
There is only one type of exception: NumberFormatException
只有一种类型的异常:NumberFormatException。
#13
10
Guava has tryParse(String), which returns null if the string couldn't be parsed, for example:
Guava有tryParse(String)，如果字符串不能解析，则返回null，例如:
Integer fooInt = Ints.tryParse(fooString);
if (fooInt != null) {
...
}
#14
10
Just for fun: You can use Java 8's Optional for converting a String into an Integer:
只是为了好玩:您可以使用Java 8的可选功能将字符串转换为整数:
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.
Here we just combine Integer.valueOf and Optinal. Probably there might be situations when this is useful - for example when you want to avoid null checks. Pre Java 8 code will look like this:
这里我们把整数结合起来。返回对象的值和秦山核电。可能在某些情况下这是有用的——例如，当您想避免空检查时。Pre - Java 8代码如下:
Integer value = (str == null) ? -1 : Integer.parseInt(str);
#15
10
Methods to do that:
方法:
- Integer.parseInt(s)
- Integer.parseInt(s)
- Integer.parseInt(s, radix)
- 整数。方法(年代,基数)
- Integer.parseInt(s, beginIndex, endIndex, radix)
- 整数。方法(s beginIndex endIndex基数)
- Integer.parseUnsignedInt(s)
- Integer.parseUnsignedInt(s)
- Integer.parseUnsignedInt(s, radix)
- 整数。parseUnsignedInt(年代,基数)
- Integer.parseUnsignedInt(s, beginIndex, endIndex, radix)
- 整数。parseUnsignedInt(s beginIndex endIndex基数)
- Integer.valueOf(s)
- Integer.valueOf(s)
- Integer.valueOf(s, radix)
- 整数。返回对象的值(s,基数)
- Integer.decode(s)
- Integer.decode(s)
- NumberUtils.toInt(s)
- NumberUtils.toInt(s)
- NumberUtils.toInt(s, defaultValue)
- NumberUtils。defaultValue toInt(年代)
Integer.valueOf produces Integer object, all other methods - primitive int.
整数。valueOf产生整数对象，所有其他方法——原语int。
Last 2 methods from commons-lang3 and big article about converting here.
最后两种方法来自common -lang3和big article关于转换。
#16
9
You can also begin by removing all non-numerical characters and then parsing the int:
您还可以首先删除所有非数字字符，然后解析int:
string mystr = mystr.replaceAll( "[^\\d]", "" );
int number= Integer.parseInt(mystr);
But be warned that this only works for non-negative numbers.
但请注意，这只适用于非负数。
#17
8
Apart from these above answers, I would like to add several functions:
除了以上这些答案，我还想补充几个功能:
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;
}
And here are results while you running them:
这里是你运行它们的结果:
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
}
#18
6
You can use this code also, with some precautions.
您也可以使用此代码，并采取一些预防措施。
-
Option #1: Handle the exception explicitly, for example, showing a message dialog and then stop the execution of the current workflow. For example:
选项#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; } -
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
选项#2:如果执行流可以在异常情况下继续，则重置受影响的变量。例如，在catch块中进行一些修改。
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.
使用字符串常量进行比较或任何类型的计算总是一个好主意，因为一个常量永远不会返回空值。
#19
6
As mentioned Apache Commons NumberUtils can do it. Which return 0 if it cannot convert string to int.
正如前面提到的，Apache Commons NumberUtils可以做到这一点。如果不能将字符串转换为int，则返回0。
You can also define your own default value.
您还可以定义自己的默认值。
NumberUtils.toInt(String str, int defaultValue)
example:
例子:
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;
#20
6
You can use new Scanner("1244").nextInt(). Or ask if even an int exists: new Scanner("1244").hasNextInt()
您可以使用新的扫描器(“1244”)。或者询问一个int是否存在:新的扫描器(“1244”)。
#21
4
In programming competitions, where you're assured that number will always be a valid integer, then you can write your own method to parse input. This will skip all validation related code (since you don't need any of that) and will be a bit more efficient.
在编程竞赛中，您可以确保数字始终是一个有效的整数，然后您可以编写自己的方法来解析输入。这将跳过所有与验证相关的代码(因为您不需要这些代码)，并且将会更加高效。
-
For valid positive integer:
有效的正整数:
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; } -
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; } -
If you are expecting a whitespace before or after these numbers, then make sure to do a
str = str.trim()before processing further.如果您期望在这些数字之前或之后有一个空格，那么在进一步处理之前一定要做一个str = str.trim()。
#22
3
For normal string you can use:
对于普通的字符串，您可以使用:
int number = Integer.parseInt("1234");
For String builder and String buffer you can use:
对于字符串生成器和字符串缓冲区，您可以使用:
Integer.parseInt(myBuilderOrBuffer.toString());
#23
3
int foo=Integer.parseInt("1234");
Make sure there is no non-numeric data in the string.
确保字符串中没有非数值数据。
#24
3
Here we go
我们开始吧
String str="1234";
int number = Integer.parseInt(str);
print number;//1234
#25
2
Use Integer.parseInt() and put it inside a try...catch block to handle any errors just in case a non-numeric character is entered, for example,
使用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);
}
}
#26
2
Simply you can try this:
你可以试试这个:
- Use
Integer.parseInt(your_string);to convert aStringtoint - 使用Integer.parseInt(your_string);将字符串转换为整数。
- Use
Double.parseDouble(your_string);to convert aStringtodouble - 使用Double.parseDouble(your_string);将字符串转换为double。
Example
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
#27
1
One method is parseInt(String) returns a primitive int
一个方法是parseInt(String)返回一个原语int。
String number = "10";
int result = Integer.parseInt(number);
System.out.println(result);
Second method is valueOf(String) returns a new Integer() object.
第二个方法是valueOf(String)返回一个新的Integer()对象。
String number = "10";
Integer result = Integer.valueOf(number);
System.out.println(result);
#28
1
This is Complete program with all conditions positive, negative without using library
这是一个完整的程序，所有的条件都是积极的，否定的，不使用图书馆。
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;
}
}
#29
0
Use this line to parse a string value to int:
使用这一行来将字符串值解析为int:
String x = "11111111";
int y = Integer.parseInt(x);
System.out.println(y);
#30
-6
Alternatively, you can use Integer.valueOf(). It will return an Integer object.
或者，您也可以使用Integer.valueOf()。它将返回一个整数对象。
String numberStringFormat = "10";
Integer resultIntFormat = Integer.valueOf(numberStringFormat);
LOG.info("result:"+result);
Output:
10
10