如何在Java中将String转换为int？

Question

我怎么能转换String成intJava中？

我的字符串只包含数字,我想返回它代表的数字.

例如,给定字符串"1234",结果应该是数字1234.

Answer 1

String myString = "1234";
int foo = Integer.parseInt(myString);

如果你查看Java文档,你会注意到"catch"是这个函数可以抛出一个NumberFormatException,当然你必须处理:

int foo;
try {
   foo = Integer.parseInt(myString);
}
catch (NumberFormatException e)
{
   foo = 0;
}

(此处理默认为格式错误的数字0,但如果您愿意,可以执行其他操作.)

或者,您可以使用IntsGuava库中的方法,该方法与Java 8结合使用Optional,可以将字符串转换为int的强大而简洁的方法:

import com.google.common.primitives.Ints;

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

Answer 2

例如,有两种方法:

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

这些方法之间略有不同:

• valueOf 返回一个新的或缓存的实例 java.lang.Integer
• parseInt返回原语int.

所有情况都是如此:Short.valueOf/ parseShort,Long.valueOf/ parseLong等.

Answer 3

好吧,需要考虑的一个非常重要的一点是,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.
}

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

Answer 4

手动完成:

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

Answer 5

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

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

Apache实用程序很好,因为如果字符串是无效的数字格式,则始终返回0.因此保存try catch块.

Apache NumberUtils API版本3.4

Answer 6

目前我正在为大学做作业,在那里我不能使用某些表达式,例如上面的表达式,通过查看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,我们可以做任何数学运算.

我们将后者(lastdigit)除以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

Answer 7

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

Answer 8

只要给定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));

虽然这仍然在内部使用流控制的异常,但使用代码变得非常干净.

Answer 9

将字符串转换为int比仅转换数字更复杂.您已经考虑过以下问题:

• 字符串只包含数字0-9吗？
• 怎么了- /+在字符串之前或之后？这是可能的(指会计数字)？
• 这是怎么回事用MAX _-/MIN_INFINITY？如果字符串是99999999999999999999会发生什么？机器可以将此字符串视为int吗？

Answer 10

方法:

 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.

最后2种方法从公地lang3和有关转换的大文章在这里.

Answer 11

我们可以使用包装类的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工具类的转换:

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

Answer 12

我有一个解决方案,但我不知道它有多有效.但它运作良好,我认为你可以改进它.另一方面,我使用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));
        }
    }
}

Answer 13

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

Answer 14

Guava有tryParse(String),null如果无法解析字符串则会返回,例如:

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

Answer 15

您也可以先删除所有非数字字符,然后解析int:

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

但请注意,这仅适用于非负数.

Answer 16

除了以上这些答案,我想添加几个功能:

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

Answer 17

您也可以使用此代码,并采取一些预防措施.

• 选项#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;
  }
  

使用字符串常量进行比较或任何类型的计算总是一个好主意,因为常量永远不会返回空值.

Answer 18

如上所述,Apache Commons NumberUtils可以做到这一点.0如果它不能将字符串转换为int,则返回哪个.

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

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;

Answer 19

你可以用new Scanner("1244").nextInt().或者询问是否存在int:new Scanner("1244").hasNextInt()

Answer 20

在编程竞赛中,您可以确保数字始终是有效整数,然后您可以编写自己的方法来解析输入.这将跳过所有与验证相关的代码(因为您不需要任何相关代码)并且会更有效率.

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()在进一步处理之前执行此操作.

Answer 21

对于普通字符串,您可以使用:

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

对于String builder和String buffer,您可以使用:

Integer.parseInt(myBuilderOrBuffer.toString());

Answer 22

你可以试试这个:

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

Answer 23

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

确保字符串中没有非数字数据.

Answer 24

我有点意外,没有人提到将String作为参数的Integer构造函数.
所以,这是:

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

Java 8 - Integer(String).

当然,构造函数将返回类型Integer,而取消装箱操作会将值转换为int.

提到
这个构造函数调用parseInt方法很重要.

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

Answer 25

开始了

String str="1234";
int number = Integer.parseInt(str);
print number;//1234

Answer 26

使用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);
    }
 }

Answer 27

它可以通过以下七种方式完成：

import com.google.common.primitives.Ints;
import org.apache.commons.lang.math.NumberUtils;

String number = "999";

1）使用Ints.tryParse：

int result = Ints.tryParse(number);

2）使用NumberUtils.createInteger：

Integer result = NumberUtils.createInteger(number);

3）使用NumberUtils.toInt：

int result = NumberUtils.toInt(number);

4）使用Integer.valueOf：

Integer result = Integer.valueOf(number);

5）使用Integer.parseInt：

int result = Integer.parseInt(number);

6）使用Integer.decode：

int result = Integer.decode(number);

7）使用Integer.parseUnsignedInt：

int result = Integer.parseUnsignedInt(number);