it-swarm.cn

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

如何在Java中将String转换为int

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

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

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

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

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

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

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

import com.google.common.primitives.Ints;

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

例如,有两种方法:

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

这些方法之间略有不同: 

  • valueOf返回Java.lang.Integer的新实例或缓存实例
  • parseInt返回原始int。 

对于所有情况都是如此:Short.valueOf/parseShortLong.valueOf/parseLong等。

629
smas

好吧,需要考虑的一个非常重要的一点是Integer解析器抛出NumberFormatException,如 Javadoc 中所述。 

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

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

230
Ali Akdurak

手动完成:

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

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

我们将时间2/10 = 0.2中的后者(lastdigit)除以10(因此为什么加倍),如下所示:

 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
42
Oak

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

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

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

Apache NumberUtils API版本3.4

40
Ryboflavin

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

只要给定String不包含Integer的可能性最小,就必须处理这种特殊情况。遗憾的是,标准的Java方法Integer::parseIntInteger::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));

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

25
Stefan Dollase

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

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

方法:

 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。

来自 commons-lang3 的最后两个方法和关于转换 here 的大文章。

22
Dmytro Shvechikov

我们可以使用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) of NumberUtils Utility Class 进行转换:

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

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

19
Lukas Bauer

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

只是为了好玩:您可以使用Java 8的OptionalString转换为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);
17
Anton Balaniuc

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

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

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

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

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

14
Thijser

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

    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
  }
12
nxhoaf

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

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

9
Raman Sahasi

如上所述Apache Commons NumberUtils可以做到。如果无法将字符串转换为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; 
9
Alireza Fattahi

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

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

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

9
manikant gautam

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

9
Christian Ullenboom
int foo=Integer.parseInt("1234");

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

7
iKing

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

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

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

Integer.parseInt(myBuilderOrBuffer.toString());
7
Aditya

你可以试试这个:

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

开始了

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

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

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

Java 8 - 整数(字符串) 。 

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


重要的是要提到
此构造函数调用parseInt方法。 

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

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

一种方法是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);
5
Pankaj Mandale

这是完整程序,所有条件都是正面的,不使用库的负面  

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;
     }
    }
4
Anup Gupta

Integer.parseInt(myString); - 使用包装类

3
Phani Kumar

可以通过5种方式完成:

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

1)使用Ints.tryParse

String number = "999";
int result = Ints.tryParse(number);

2)使用NumberUtils.createInteger

String number = "999";
Integer result = NumberUtils.createInteger(number);

3)使用NumberUtils.toInt

String number = "999";
int result = NumberUtils.toInt(number);

4)使用Integer.valueOf

String number = "999";
Integer result = Integer.valueOf(number);

5)使用Integer.parseInt

String number = "999";
int result = Integer.parseInt(number);
3
Santosh Jadi

顺便提一下,请注意,如果字符串为null,则调用:

int i = Integer.parseInt(null);

抛出NumberFormatException,而不是NullPointerException。

3
Pavel Molchanov

你可以使用以下任何一种: 

  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)
2
Rajeev Ranjan

import Java.util。*;

公共类strToint {

    public static void main(String[] args){

            String str = "123";

            byte barr[] = str.getBytes();

            System.out.println(Arrays.toString(barr));
            int result=0;
            for(int i=0;i<barr.length;i++){
                    //System.out.print(barr[i]+" ");
                    int ii = barr[i];
                    char a = (char)ii;
                    int no = Character.getNumericValue(a);
                    result=result*10+no;
                    System.out.println(result);

            }
            System.out.println("result:"+result);
    }

}

2
Abhijeet Kale

public static int parseInt(String s)throws NumberFormatException

您可以使用Integer.parseInt()将String转换为int。

将String 20转换为原始int。

    String n = "20";
    int r = Integer.parseInt(n);//returns a primitive int       
    System.out.println(r);

输出-20

如果字符串不包含可解析的整数。它会抛出NumberFormatException

String n = "20I";// throwns NumberFormatException
int r = Integer.parseInt(n);
System.out.println(r);

public static Integer valueOf(String s)抛出NumberFormatException

你可以使用Integer.valueOf(),在这里它将返回一个Integer对象。

String n = "20";
Integer r = Integer.valueOf(n); //returns a new Integer() object.   
System.out.println(r);

输出-20

参考文献 https://docs.Oracle.com/en/

1
Poorna Senani Gamage

String转换为Int的一些方法如下:

  1. 你可以使用Integer.parseInt()

    String test = "4568"; int new = Integer.parseInt(test);

  2. 你也可以使用Integer.valueOf()

    String test = "4568"; int new =Integer.parseInt(test);

0
ishant kulshreshtha

使用Java Integer类的parseInt方法将字符串转换为整数。 parseInt方法是将String转换为int,如果字符串无法转换为int类型,则抛出NumberFormatException

俯视它可以抛出的异常,使用这个:

int i = Integer.parseInt(myString);

如果由变量myString表示的String是一个有效的整数,如“1234”, “200”, “1”,,它将被转换为Java int。如果由于任何原因导致失败,则更改可能会抛出NumberFormatException,因此代码应该稍长一些来解释这一点。

防爆。 Java Stringint转换方法,控制可能NumberFormatException

public class JavaStringToIntExample
{
  public static void main (String[] args)
  {
    // String s = "test";  // use this if you want to test the exception below
    String s = "1234";

    try
    {
      // the String to int conversion happens here
      int i = Integer.parseInt(s.trim());

      // print out the value after the conversion
      System.out.println("int i = " + i);
    }
    catch (NumberFormatException nfe)
    {
      System.out.println("NumberFormatException: " + nfe.getMessage());
    }
  }
}

如果更改尝试失败 - 如果您可以尝试将Java String测试转换为int - 整数parseInt进程将抛出NumberFormatException,您必须在try/catch块中处理它。

0
Nisarg

你可以使用parseInt方法  

  String SrNumber="5790";
int extractNumber = Integer.parseInt(SrNumber);
System.out.println(extractNumber);//Result will be --5790
0
Sunil Dhappadhule

自定义算法:

public static int toInt(String value) {
  int output = 0;
  boolean isFirstCharacter = true;
  boolean isNegativeNumber = false;
  byte bytes[] = value.getBytes();
  for (int i = 0; i < bytes.length; i++) {
    char c = (char) bytes[i];
    if (!Character.isDigit(c)) {
      isNegativeNumber = (c == '-');
      if (!(isFirstCharacter && (isNegativeNumber || c == '+'))) {
        throw new NumberFormatException("For input string \"" + value + "\"");
      }
    } else {
      int number = Character.getNumericValue(c);
      output = output * 10 + number;
    }
    isFirstCharacter = false;
  }
  if (isNegativeNumber) output *= -1;
  return output;
}

另一个解决方案: (使用字符串 charAt 方法而不是将字符串转换为字节数组):

public static int toInt(String value) {
  int output = 0;
  boolean isFirstCharacter = true;
  boolean isNegativeNumber = false;
  for (int i = 0; i < value.length(); i++) {
    char c = value.charAt(i);
    if (!Character.isDigit(c)) {
      isNegativeNumber = (c == '-');
      if (!(isFirstCharacter && (isNegativeNumber || c == '+'))) {
        throw new NumberFormatException("For input string \"" + value + "\"");
      }
    } else {
      int number = Character.getNumericValue(c);
      output = output * 10 + number;
    }
    isFirstCharacter = false;
  }
  if (isNegativeNumber) output *= -1;
  return output;
}

例子:

int number1 = toInt("20");
int number2 = toInt("-20");
int number3 = toInt("+20");
System.out.println("Numbers = " + number1 + ", " + number2 + ", " + number3);

try {
  toInt("20 Hadi");
} catch (NumberFormatException e) {
  System.out.println("Error: " + e.getMessage());
}
0
nabeghe

使用方法:Integer.parseInt(String s)

String s = "123";
int n = Integer.parseInt(s);
0
karthik_varma_k

使用Integer.parseInt(),这将帮助您将字符串值解析为int。

例:

String str = "2017";
int i = Integer.parseInt(str);
System.out.println(i);

输出: 2017年

0
Alekya

使用此方法:

public int ConvertStringToInt(String number)
{
 int num = 0;
 try
 {
   int newNumber = Integer.ParseInt(number);
   num = newNumber;
 }
 catch(Exception ex)
 {
   num = 0;
   Log.i("Console",ex.toString);
 }
   return num;
}
0
mohamad sheikhi

尝试使用String的不同输入代码:

String a = "10";  
String a = "10ssda";  
String a = null; 
String a = "12102";

if(null != a) {
    try {
        int x = Integer.ParseInt(a.trim()); 
        Integer y = Integer.valueOf(a.trim());
        //  It will throw a NumberFormatException in case of invalid string like ("10ssda" or "123 212") so, put this code into try catch
    } catch(NumberFormatException ex) {
        // ex.getMessage();
    }
}
0
Ram Chhabra

我编写了这个快速方法来将字符串输入解析为int或long。它比当前的JDK 11 Integer.parseInt或Long.parseLong更快。虽然,你只要求int,我也包括了长解析器。下面的代码解析器要求解析器的方法必须很小才能快速运行。替代版本低于测试代码。替代版本非常快,它不依赖于类的大小。

此类检查溢出,您可以自定义代码以适应您的需要。使用我的方法,空字符串将产生0,但这是故意的。您可以更改它以适应您的情况或按原样使用。 

这只是需要parseInt和parseLong的类的一部分。请注意,这仅处理基数为10的数字。

Int解析器的测试代码低于下面的代码。 

/*
 * Copyright 2019 Khang Hoang Nguyen
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 * @author: Khang Hoang Nguyen - [email protected]
 **/
final class faiNumber{        
    private static final long[] longpow = {0L, 1L, 10L, 100L, 1000L, 10000L, 100000L, 1000000L, 10000000L, 100000000L, 1000000000L,
                                           10000000000L, 100000000000L, 1000000000000L, 10000000000000L, 100000000000000L,
                                           1000000000000000L, 10000000000000000L, 100000000000000000L, 1000000000000000000L,
                                           };

    private static final int[] intpow = { 0, 1, 10, 100, 1000, 10000,
                                          100000, 1000000, 10000000, 100000000, 1000000000 
                                        };

    /**
     * parseLong(String str) parse a String into Long. 
     * All errors throw by this method is NumberFormatException.
     * Better errors can be made to tailor to each use case.
     **/
    public static long parseLong(final String str) { 
        final int length = str.length();
        if ( length == 0 ) return 0L;        

        char c1 = str.charAt(0); int start;

        if ( c1 == '-' || c1 == '+' ){
            if ( length == 1 ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
            start = 1;
        } else {
            start = 0;
        }
        /*
         * Note: if length > 19, possible scenario is to run through the string 
         * to check whether the string contains only valid digits.
         * If the check had only valid digits then a negative sign meant underflow, else, overflow.
         */
        if ( length - start > 19 ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );

        long c; 
        long out = 0L;

        for ( ; start < length; start++){
            c = (str.charAt(start) ^ '0');
            if ( c > 9L ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
            out += c * longpow[length - start];
        }

        if ( c1 == '-' ){
            out = ~out + 1L;
            // if out > 0 number underflow(supposed to be negative).
            if ( out > 0L ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
            return out;
        }
        // if out < 0 number overflow(supposed to be positive).
        if ( out < 0L ) throw new NumberFormatException( String.format("Not a valid long value. Input '%s'.", str) );
        return out;
    }

    /**
     * parseInt(String str) parse a string into an int.
     * return 0 if string is empty. 
     **/
    public static int parseInt(final String str) { 
        final int length = str.length();
        if ( length == 0 ) return 0;        

        char c1 = str.charAt(0); int start; 

        if ( c1 == '-' || c1 == '+' ){
            if ( length == 1 ) throw new NumberFormatException( String.format("Not a valid integer value. Input '%s'.", str) );
            start = 1;
        } else {
            start = 0;
        }

        int out = 0; int c;
        int runlen = length - start;

        if ( runlen > 9 ) {
            if ( runlen > 10 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );

            c = (str.charAt(start) ^ '0');   // <- Any number from 0 - 255 ^ 48 will yield greater than 9 except 48 - 57
            if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            if ( c > 2 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            out += c * intpow[length - start++];
        }

        for ( ; start < length; start++){
            c = (str.charAt(start) ^ '0');
            if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            out += c * intpow[length - start];
        }

        if ( c1 == '-' ){
            out = ~out + 1;
            if ( out > 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
            return out;
        }

        if ( out < 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        return out;
    }
}

测试代码部分。这应该需要大约200秒左右。

// Int Number Parser Test;
long start = System.currentTimeMillis();    
System.out.println("INT PARSER TEST");
for (int i = Integer.MIN_VALUE; i != Integer.MAX_VALUE; i++){
   if( faiNumber.parseInt(""+i) != i ) System.out.println("Wrong");
   if ( i == 0 ) System.out.println("HalfWay Done");
}

if( faiNumber.parseInt(""+Integer.MAX_VALUE) != Integer.MAX_VALUE ) System.out.println("Wrong");
long end = System.currentTimeMillis();
long result = (end - start);
System.out.println(result);        
// INT PARSER END */

另一种方法也非常快。注意,不使用int pow的数组,而是通过位移乘以10的数学优化。

public static int parseInt(final String str) { 
    final int length = str.length();
    if ( length == 0 ) return 0;        

    char c1 = str.charAt(0); int start; 

    if ( c1 == '-' || c1 == '+' ){
        if ( length == 1 ) throw new NumberFormatException( String.format("Not a valid integer value. Input '%s'.", str) );
        start = 1;
    } else {
        start = 0;
    }

    int out = 0; int c;
    while( start < length && str.charAt(start) == '0' ) start++; // <-- This to disregard leading 0, can be removed if you know exactly your source does not have leading zeroes.
    int runlen = length - start;

    if ( runlen > 9 ) {
        if ( runlen > 10 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );

        c = (str.charAt(start++) ^ '0');   // <- Any number from 0 - 255 ^ 48 will yield greater than 9 except 48 - 57
        if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        if ( c > 2 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        out = (out << 1) + (out << 3) + c; // <- alternatively this can just be out = c or c above can just be out;
    }

    for ( ; start < length; start++){
        c = (str.charAt(start) ^ '0');
        if ( c > 9 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        out = (out << 1) + (out << 3) + c; 
    }

    if ( c1 == '-' ){
        out = ~out + 1;
        if ( out > 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
        return out;
    }

    if ( out < 0 ) throw new NumberFormatException( String.format("Not a valid integer value. Input: '%s'.", str) );
    return out;
}
0
Kevin Ng