如何将 String
转换为 int
?
"1234" → 1234
String myString = "1234";
int foo = Integer.parseInt(myString);
如果您查看 Java documentation,您会注意到“捕获”是此函数可以抛出一个 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)
例如,这里有两种方法:
Integer x = Integer.valueOf(str);
// or
int y = Integer.parseInt(str);
这些方法之间存在细微差别:
valueOf 返回一个新的或缓存的 java.lang.Integer 实例
parseInt 返回原始 int。
所有情况都相同:Short.valueOf
/parseShort
、Long.valueOf
/parseLong
等。
valueOf
方法只是 return valueOf(parseInt(string));
嗯,需要考虑的一个非常重要的点是整数解析器会抛出 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.
}
在尝试从拆分参数获取整数值或动态解析某些内容时,处理此异常很重要。
"([0-9]+)"
的正则表达式模式将“捕获”一个或多个数字从 1 到 9 的第一个序列。查看该包中的 Matcher
类。
手动执行:
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;
}
Integer.parseInt(s)
? - 我明白这是一个面试问题的意义,但是a)这并不意味着你会这样做(这是提问者所问的),b)这个答案无论如何都是一个非常糟糕的例子。
另一种解决方案是使用 Apache Commons' NumberUtils:
int num = NumberUtils.toInt("1234");
Apache 实用程序很好,因为如果字符串是无效的数字格式,则总是返回 0。因此为您节省了 try catch 块。
Apache NumberUtils API Version 3.4
整数解码
您也可以使用 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
,您可以使用:
拆箱:int val = Integer.decode("12"); intValue(): Integer.decode("12").intValue();
目前我正在为大学做作业,我不能使用某些表达式,例如上面的那些,通过查看 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
'0'
而不是 { 2} 并且永远不必担心它的实际数值。第三,带有 double
值的整个绕道根本没有意义,因为您要除以十,然后再乘以十。结果简直就是semilastdigit * 10 + lastdigit
,正如小学所学的那样,当时引入了十进制系统......
这样做的方法:
Integer.parseInt(s) Integer.parseInt(s, radix) Integer.parseInt(s, beginIndex, endIndex, radix) Integer.parseUnsignedInt(s) Integer.parseUnsignedInt(s, radix) Integer.parseUnsignedInt(s, beginIndex, endIndex, radix) Integer.valueOf(s) Integer.valueOf(s, radix) Integer.decode(s) NumberUtils.toInt(s) NumberUtils.toInt(s, defaultValue)
Integer.valueOf
生成一个 Integer
对象,所有其他方法生成一个原始 int。
最后两种方法来自 commons-lang3 和一篇关于转换 here 的大文章。
每当给定的 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 "12"
System.out.println(tryParseInteger("12").map(i -> i.toString()).orElse("invalid"));
// prints "-1"
System.out.println(tryParseInteger("-1").map(i -> i.toString()).orElse("invalid"));
// prints "invalid"
System.out.println(tryParseInteger("ab").map(i -> i.toString()).orElse("invalid"));
虽然这仍然在内部使用异常进行流控制,但使用代码变得非常干净。此外,您可以清楚地区分 -1
被解析为有效值的情况和无法解析无效字符串的情况。
使用 Integer.parseInt(yourString)
。
记住以下几点:
Integer.parseInt("1");
// 好的
Integer.parseInt("-1");
// 好的
Integer.parseInt("+1");
// 好的
Integer.parseInt(" 1");
// 异常(空格)
Integer.parseInt("2147483648");
// 异常(整数限制为 2,147,483,647 的 maximum value)
Integer.parseInt("1.1");
// 异常(. 或 , 或任何不允许的)
Integer.parseInt("");
// 异常(不是 0 什么的)
只有一种类型的异常:NumberFormatException
将字符串转换为 int 比仅转换数字更复杂。您考虑过以下问题:
字符串是否只包含数字 0-9?
字符串之前或之后的 -/+ 是怎么回事?这可能吗(指会计数字)?
MAX_-/MIN_INFINITY 怎么了?如果字符串是 999999999999999999999 会发生什么?机器可以将此字符串视为 int 吗?
我们可以使用 Integer
包装类的 parseInt(String str)
方法将字符串值转换为整数值。
例如:
String strValue = "12345";
Integer intValue = Integer.parseInt(strVal);
Integer
类还提供 valueOf(String str)
方法:
String strValue = "12345";
Integer intValue = Integer.valueOf(strValue);
我们还可以使用 NumberUtils Utility Class 的 toInt(String strValue)
进行转换:
String strValue = "12345";
Integer intValue = NumberUtils.toInt(strValue);
我有一个解决方案,但我不知道它的效果如何。但它运作良好,我认为你可以改进它。另一方面,我用 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));
}
}
}
您还可以从删除所有非数字字符开始,然后解析整数:
String mystr = mystr.replaceAll("[^\\d]", "");
int number = Integer.parseInt(mystr);
但请注意,这只适用于非负数。
-42
被解析为 42
。
Google Guava 有 tryParse(String),如果无法解析字符串,则返回 null
,例如:
Integer fooInt = Ints.tryParse(fooString);
if (fooInt != null) {
...
}
除了以前的答案,我想添加几个功能。这些是您使用它们时的结果:
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;
}
如前所述,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;
您可以使用 new Scanner("1244").nextInt()
。或者询问是否存在 int:new Scanner("1244").hasNextInt()
您也可以使用此代码,但要采取一些预防措施。
选项 #1:显式处理异常,例如,显示消息对话框,然后停止当前工作流的执行。例如:尝试 { String stringValue = "1234"; // 从字符串到整数 int integerValue = Integer.valueOf(stringValue); // 或者 int integerValue = Integer.ParseInt(stringValue); // 现在从整数返回到字符串 stringValue = String.valueOf(integerValue); } catch (NumberFormatException ex) { //JOptionPane.showMessageDialog(frame, "Invalid input string!"); System.out.println("输入字符串无效!");返回; }
选项 #2:如果发生异常时执行流程可以继续,则重置受影响的变量。例如,在 catch 块中进行一些修改 catch (NumberFormatException ex) { integerValue = 0; }
使用字符串常量进行比较或任何类型的计算总是一个好主意,因为常量永远不会返回空值。
在编程竞赛中,您确信数字始终是有效整数,然后您可以编写自己的方法来解析输入。这将跳过所有与验证相关的代码(因为您不需要任何代码)并且效率更高。
对于有效的正整数: private static int parseInt(String str) { int i, n = 0;对于 (i = 0; i < str.length(); i++) { n *= 10; n += str.charAt(i) - 48; } 返回 n; } 对于正整数和负整数: private static int parseInt(String str) { int i=0, n=0, sign=1; if (str.charAt(0) == '-') { i = 1;符号 = -1; } for(; i
对于普通字符串,您可以使用:
int number = Integer.parseInt("1234");
对于字符串生成器和字符串缓冲区,您可以使用:
Integer.parseInt(myBuilderOrBuffer.toString());
你可以试试这个:
使用 Integer.parseInt(your_string);将 String 转换为 int
使用 Double.parseDouble(your_string);将字符串转换为双精度
例子
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
int foo = Integer.parseInt("1234");
确保字符串中没有非数字数据。
开始了
String str = "1234";
int number = Integer.parseInt(str);
print number; // 1234
我有点惊讶没有人提到将 String 作为参数的 Integer 构造函数。
所以,这里是:
String myString = "1234";
int i1 = new Integer(myString);
当然,构造函数会返回类型 Integer
,并且拆箱操作会将值转换为 int
。
注意 1:重要的是要提及:此构造函数调用 parseInt
方法。
public Integer(String var1) throws NumberFormatException {
this.value = parseInt(var1, 10);
}
注意 2:已弃用:@Deprecated(since="9")
- JavaDoc。
使用 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);
}
}
它可以通过七种方式完成:
import com.google.common.primitives.Ints;
import org.apache.commons.lang.math.NumberUtils;
String number = "999";
Ints.tryParse: int result = Ints.tryParse(number); NumberUtils.createInteger: 整数结果 = NumberUtils.createInteger(number); NumberUtils.toInt: int 结果 = NumberUtils.toInt(number); Integer.valueOf: 整数结果 = Integer.valueOf(number); Integer.parseInt: int result = Integer.parseInt(number); Integer.decode: int result = Integer.decode(number); Integer.parseUnsignedInt: int result = Integer.parseUnsignedInt(number);
这是一个完整的程序,所有条件都是正面和负面的,无需使用库
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;
}
}
Integer.parseInt
。
一种方法是 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);
公共静态 int parseInt(String s) 抛出 NumberFormatException
您可以使用 Integer.parseInt()
将 String 转换为 int。
将字符串 "20" 转换为原始 int:
String n = "20";
int r = Integer.parseInt(n); // Returns a primitive int
System.out.println(r);
输出 20
如果字符串不包含可解析的整数,则会抛出 NumberFormatException
:
String n = "20I"; // Throws NumberFormatException
int r = Integer.parseInt(n);
System.out.println(r);
公共静态整数 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/
不定期副业成功案例分享