如何将一个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 / parseShortLong.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你可以使用:

  1. 拆箱:

     int val = Integer.decode("12"); 
  2. 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::parseIntInteger::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.valueOfOptinal结合起来。 可能有些情况下,这是有用的 – 例如,当你想避免空检查。 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有关的代码(因为你不需要任何这些代码),并且会更高效。

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

开始了

 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中没有非数字数据。

方法做到这一点:

  1. 的Integer.parseInt(S)
  2. Integer.parseInt(s,基数)
  3. Integer.parseInt(s,beginIndex,endIndex,radix)
  4. Integer.parseUnsignedInt(S)
  5. Integer.parseUnsignedInt(s,基数)
  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。

最后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()); }