java int转string string转double - 如何在Java中将String转换为int?




15 Answers

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

有关更多信息,请参阅Java文档

string转int char转int

如何在Java中将String转换为int

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

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




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

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




目前我正在为大学做作业,在那里我不能使用某些表达式,例如上面的表达式,通过查看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”这样的“魔术”表达式



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



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

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



方法:

 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最后两种方法和关于转换的大文章。




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



Guava有tryParse(String) ,如果无法解析字符串,则返回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
  }



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

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




如上所述,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; 



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

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

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

Integer.parseInt(myBuilderOrBuffer.toString());



开始了

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



一种方法是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;
     }
    }



Related