如何将一个string转换为Java中的int？
如何将String转换为Java中的int ？
我的string只包含数字，我想返回它表示的数字。
例如，给定string"1234"的结果应该是数字1234 。
int foo = Integer.parseInt("1234");
有关更多信息，请参阅Java文档 。
（如果你在StringBuilder （或古老的StringBuffer ）中，你需要做Integer.parseInt(myBuilderOrBuffer.toString()); ）。
例如，这里有两种方法：
Integer x = Integer.valueOf(str); // or int y = Integer.parseInt(str);
这些方法之间有一点点区别：
-
valueOf返回一个新的或caching的java.lang.Integer实例 -
parseInt返回原始的int。
对于所有情况也是如此： Short.valueOf / parseShort ， Long.valueOf / parseLong等
那么，需要考虑的一个非常重要的问题是整数分析器抛出了Javadoc中所述的NumberFormatExceptionexception。
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参数中获取整数值或dynamicparsing某些内容时，处理此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; }
目前我正在做大学的任务，在那里我不能使用某些expression式，比如上面的expression式，通过查看ASCII表格，我设法做到了这一点。 这是一个更复杂的代码，但它可以帮助像我一样受限的其他人。
首先要做的是接收input，在这种情况下是一串数字。 我将其称为String number ，在这种情况下，我将使用数字12来举例说明，因此String number = "12";
另一个限制是我不能使用重复的循环，因此，循环（这将是完美的）也不能使用。 这限制了我们一些，但是再一次，这就是目标。 由于我只需要两位数字（取最后两位数字），一个简单的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，没有任何我们可以做的math运算。
我们以时尚2/10 = 0.2 （后来为什么加倍）将后者（lastdigit）除以10：
lastdigit = lastdigit/10;
这只是玩数字。 我们将最后一位数字转换成小数。 但现在看看会发生什么：
double jointdigits = semilastdigit + lastdigit; // 1.0 + 0.2 = 1.2
不要太深入math，我们只是将单位的数字隔开。 你看，因为我们只考虑0-9，所以除以10的倍数就像创build一个存储它的“盒子”（回想起你的一年级老师何时解释你是一个单位还是一百个单位）。 所以：
int finalnumber = (int) (jointdigits*10); // Be sure to use parentheses "()"
你去了。 考虑到以下限制，您将一串数字（在本例中为两位数）转换为由这两位数组成的整数：
- 没有重复的周期
- 没有“魔术”expression式，如parseInt
另一个解决scheme是使用Apache Commons的 NumberUtils：
int num = NumberUtils.toInt("1234");
Apache实用程序很好，因为如果string是无效的数字格式，则总是返回0。 因此保存你的try catch块。
Apache NumberUtils API版本3.4
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();
将string转换为int比仅转换数字更为复杂。 您已经考虑了以下问题：
- string是否只包含数字0-9 ？
- string之前或之后的– / +是怎么回事？ 这是可能的（指会计数字）？
- MAX _- / MIN_INFINITY是什么？ 如果string是99999999999999999999，会发生什么？ 机器能把这个string当作int吗？
我们可以使用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) 工具类的 toInt(String strValue)进行转换：
String strValue = "12345"; Integer intValue = NumberUtils.toInt(strValue);
我有一个解决scheme，但我不知道它是多么有效。 但它运作良好，我认为你可以改进它。 另一方面，我用JUnit做了几个testing，正确地执行了一些步骤。 我附加了function和testing：
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进行testing：
@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)); } } }
只要给定的string不包含Integer的可能性很小，就必须处理这个特殊情况。 可悲的是，标准的Java方法Integer::parseInt和Integer::valueOf抛出一个NumberFormatException来表示这种特殊情况。 因此，您必须使用stream控制的exception，这通常被认为是不好的编码风格。
在我看来，这个特殊情况应该通过返回一个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));
虽然内部仍然使用stream量控制的exception，但使用代码变得非常干净。
只是为了好玩：您可以使用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);
Guava有tryParse（String） ，如果不能parsingstring，则返回null ，例如：
Integer fooInt = Ints.tryParse(fooString); if (fooInt != null) { ... }
除了上面这些答案之外，我想补充几个函数：
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; }
当你运行它们时，结果如下：
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 }
您可以使用new Scanner("1244").nextInt() 。 或者询问是否存在int： new Scanner("1244").hasNextInt()
您也可以先删除所有非数字字符，然后parsingint：
string mystr = mystr.replaceAll( "[^\\d]", "" ); int number= Integer.parseInt(mystr);
但要警告的是，这只适用于非负数。
您也可以使用此代码，并采取一些预防措施。
-
选项＃1：显式处理exception，例如显示消息对话框，然后停止执行当前工作stream程。 例如：
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：如果在exception情况下执行stream程可以继续，则重置受影响的variables。 例如，在catch块中进行了一些修改
catch (NumberFormatException ex) { integerValue = 0; }
使用string常量进行比较或任何计算总是一个好主意，因为常量永远不会返回空值。
正如前面提到的Apache Commons NumberUtils可以做到的。 如果无法将string转换为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;
在编程竞赛中，如果您确信编号总是有效的整数，那么您可以编写自己的方法来parsinginput。 这将跳过所有与validation有关的代码（因为你不需要任何这些代码），并且会更高效。
-
对于有效的正整数：
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()。
开始了
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"); //exception（空白）
Integer.parseInt("2147483648"); //例外（整数限制为最大值 2,147,483,647）
Integer.parseInt("1.1"); //exception（ 。或者，或者其他不允许的）
Integer.parseInt(""); //exception（不是0或者其他）
只有一种types的exception： NumberFormatException
int foo=Integer.parseInt("1234");
确保string中没有非数字数据。
方法做到这一点：
- 的Integer.parseInt（S）
- Integer.parseInt（s，基数）
- Integer.parseInt（s，beginIndex，endIndex，radix）
- Integer.parseUnsignedInt（S）
- Integer.parseUnsignedInt（s，基数）
- Integer.parseUnsignedInt（s，beginIndex，endIndex，radix）
- Integer.valueOf（S）
- Integer.valueOf（s，radix）
- Integer.decode（S）
- NumberUtils.toInt（S）
- NumberUtils.toInt（s，defaultValue）
Integer.valueOf生成Integer对象，所有其他方法 – primitive int。
最后2种方法来自commons-lang3和关于在这里转换的大文章。
对于正常string，你可以使用：
int number = Integer.parseInt("1234");
对于string生成器和string缓冲区，您可以使用：
Integer.parseInt(myBuilderOrBuffer.toString());
一种方法是parseInt（String）返回一个原始的int
String number = "10"; int result = Integer.parseInt(number); System.out.println(result);
第二种方法是valueOf（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; } }
使用这一行来parsing一个string值为int：
String x = "11111111"; int y = Integer.parseInt(x); System.out.println(y);
只要你可以试试这个：
- 使用
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
使用Integer.parseInt（）并将其放在try … catch块中，以便在input非数字字符的情况下处理任何错误，例如
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 s="100"; try { int i=Integer.parseInt( s ); }catch( Exception e ) { System.out.println(e.getMessage()); } String s="100L"; try { int i=Integer.parseInt( s ); }catch( Exception e ) { System.out.println(e.getMessage()); }
