如何将字符串转换成Java中的int类型?

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

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

See the Java Documentation for more information.

有关更多信息，请参见Java文档。

#2

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:

这些方法之间有细微的差别:

• valueOf returns a new or cached instance of java.lang.Integer
• valueOf返回一个新的或缓存的java.lang.Integer实例。
• parseInt returns primitive int.
• 方法用于返回原始int。

The same is for all cases: Short.valueOf/parseShort, Long.valueOf/parseLong, etc.

所有的情况都是一样的:短。返回对象的值/ parseShort,长。返回对象的值/ parseLong等等。

#3

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

Do it manually:

手动启动:

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

#5

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

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

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:

如果你想要整数而不是整数，你可以使用:

1. Unboxing:

   拆箱:

   int val = Integer.decode("12"); 
   

2. intValue():

   intValue():

   Integer.decode("12").intValue();
   

#8

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

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

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

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

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

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

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

Methods to do that:

方法:

1. Integer.parseInt(s)
2. Integer.parseInt(s)
3. Integer.parseInt(s, radix)
4. 整数。方法(年代,基数)
5. Integer.parseInt(s, beginIndex, endIndex, radix)
6. 整数。方法(s beginIndex endIndex基数)
7. Integer.parseUnsignedInt(s)
8. Integer.parseUnsignedInt(s)
9. Integer.parseUnsignedInt(s, radix)
10. 整数。parseUnsignedInt(年代,基数)
11. Integer.parseUnsignedInt(s, beginIndex, endIndex, radix)
12. 整数。parseUnsignedInt(s beginIndex endIndex基数)
13. Integer.valueOf(s)
14. Integer.valueOf(s)
15. Integer.valueOf(s, radix)
16. 整数。返回对象的值(s,基数)
17. Integer.decode(s)
18. Integer.decode(s)
19. NumberUtils.toInt(s)
20. NumberUtils.toInt(s)
21. NumberUtils.toInt(s, defaultValue)
22. 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

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

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

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

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

You can use new Scanner("1244").nextInt(). Or ask if even an int exists: new Scanner("1244").hasNextInt()

您可以使用新的扫描器(“1244”)。或者询问一个int是否存在:新的扫描器(“1244”)。

#21

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.

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

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

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

    

    

3. 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

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

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

Make sure there is no non-numeric data in the string.

确保字符串中没有非数值数据。

#24

Here we go

我们开始吧

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

#25

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

Simply you can try this:

你可以试试这个:

• Use Integer.parseInt(your_string); to convert a String to int
• 使用Integer.parseInt(your_string);将字符串转换为整数。
• Use Double.parseDouble(your_string); to convert a String to double
• 使用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

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

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

Use this line to parse a string value to int:

使用这一行来将字符串值解析为int:

 String x = "11111111";
 int y = Integer.parseInt(x);
 System.out.println(y);

#30

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