blocks|key|2229|text|标准库afaik中不存在类似于此的内容，但是您可以编写一个将String解析为如下所示的Optional<Integer>的方法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2230|public+static+Optional<Integer>+parseInt(String+toParse)+{
++++try+{
++++++++return+Optional.of(Integer.parseInt(toParse));
++++}+catch+(NumberFormatException+e)+{
++++++++return+Optional.empty();
++++}
}|code-block|syntax|javascript|2231|entityMap^0|U|6|18|H|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

There doesn't exist anything like this in the standard library afaik, but you can write a method that parses a <code>String</code> into an <code>Optional&lt;Integer&gt;</code> like this:

<pre><code>public static Optional&lt;Integer&gt; parseInt(String toParse) {
 try {
 return Optional.of(Integer.parseInt(toParse));
 } catch (NumberFormatException e) {
 return Optional.empty();
 }
}
</code></pre>

blocks|key|2268|text|如果没有尝试捕获，并且仍然返回一个可选的--您可以这样做。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2269|Optional<Integer>+result+=+Optional.ofNullable(input)
++++.filter(str+->+str.matches("-?\\d%2B"))
++++.map(Integer::parseInt);|code-block|syntax|javascript|2270|编辑：Regex更新以支持负数|offset|length|style|BOLD|2271|警告：正如注释中指出的，如果解析的字符串超出了Integer.MIN_VALUE和Integer.MAX_VALUE的范围，仍然会抛出RuntimeException|CODE|2272|entityMap^0|0|0|0|2|0|0|2|N|H|15|H|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|T|8|@$I|U|J|V|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|W|8|@$I|X|J|Y|K|L]|$I|Z|J|10|K|O]|$I|11|J|12|K|O]]|9|@]|A|$]]|$1|P|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|Q|$]]

Without a try-catch and still returning an Optional - you could do

<pre><code>Optional&lt;Integer&gt; result = Optional.ofNullable(input)
 .filter(str -&gt; str.matches("-?\\d+"))
 .map(Integer::parseInt);
</code></pre>

EDIT: Regex updated to support negative numbers

WARNING: As pointed out in the comments, will still throw a RuntimeException if the parsed String turns out to be outside the range of <code>Integer.MIN_VALUE</code> and <code>Integer.MAX_VALUE</code>

blocks|key|7246|text|与现在被删除的其他答案不同，我认为这与Java向后兼容并没有什么关系。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|7247|因为空Optional表示缺少的值，这意味着该方法实际上工作了，但没有返回结果。|offset|length|style|CODE|BOLD|7248|但是，将hello解析为整数将不起作用，必须抛出异常，因为是一个错误，而不是一个空结果。请记住，NumberFormatException扩展了IllegalArgumentException。|7249|更普遍地说，Optional是为处理可能缺少的值(而不是使用null+)而创建的，而不是用于错误处理。而且，Optional没有提供任何方法来知道错误是什么以及为什么会出现错误。|7250|entityMap^0|0|3|8|G|O|0|0|2P|4|5|1C|L|20|O|0|0|2H|6|8|U|4|1I|8|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]|$D|S|E|T|F|H]]|9|@]|A|$]]|$1|I|3|J|5|6|7|U|8|@$D|V|E|W|F|H]|$D|X|E|Y|F|G]|$D|Z|E|10|F|G]|$D|11|E|12|F|G]]|9|@]|A|$]]|$1|K|3|L|5|6|7|13|8|@$D|14|E|15|F|H]|$D|16|E|17|F|G]|$D|18|E|19|F|G]|$D|1A|E|1B|F|G]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|N|$]]

Unlike other answers that are now deleted, I don't think this really has to do with Java being backwards-compatible.

Because an empty <code>Optional</code> represents a value that is absent, it would mean that the method actually worked but no results are returned.

However, parsing <code>hello</code> as an integer will not work and has to throw an exception, because it is an error rather than an empty result. Keep in mind that <code>NumberFormatException</code> extends <code>IllegalArgumentException</code>.

More generally speaking, <code>Optional</code> was made for dealing with possibly absent values (instead of using <code>null</code> for that), and not for error handling. Also, <code>Optional</code> doesn't provide any way to know what is the error and why there is one.

blocks|key|2359|text|我不想推测为什么不存在这样的方法，但是如果您不愿意，执行预测试或捕获异常，则需要重新实现。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2360|public+static+OptionalInt+parseInt(String+s)+{
++++if(s.isEmpty())+return+OptionalInt.empty();
++++final+int+len+=+s.length(),+limit;
++++final+boolean+negative;
++++int+i+=+0;
++++switch(s.charAt(0))+{
++++++++case+'-':
++++++++++++i=1;
++++++++++++if(len==1)+return+OptionalInt.empty();
++++++++++++negative+=+true;
++++++++++++limit+=+Integer.MIN_VALUE;
++++++++++++break;
++++++++case+'%2B':
++++++++++++i=1;
++++++++++++if(len==1)+return+OptionalInt.empty();
++++++++++++//+fall-through
++++++++default:
++++++++++++negative+=+false;
++++++++++++limit+=+-Integer.MAX_VALUE;
++++}
++++final+int+limitBeforeMul+=+limit+/+10;
++++int+result+=+0;
++++for(;+i+<+len;+i%2B%2B)+{
++++++++int+digit+=+Character.digit(s.charAt(i),+10);
++++++++if(digit+<+0+%7C%7C+result+<+limitBeforeMul+%7C%7C+(result+*=+10)+<+limit+%2B+digit)
++++++++++++return+OptionalInt.empty();
++++++++result+-=+digit;
++++}
++++return+OptionalInt.of(negative?+result:+-result);
}|code-block|syntax|javascript|2361|这基本上与Integer.parseInt相同，但是返回无效字符串的空OptionalInt，而不是抛出异常…。|offset|length|style|CODE|2362|正如您可能注意到的，最困难的部分是处理接近Integer.MIN_VALUE+resp的数字。正确的Integer.MAX_VALUE。|2363|entityMap^0|0|0|5|G|Z|B|0|L|H|1E|H|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@$I|Y|J|Z|K|L]|$I|10|J|11|K|L]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|P|$]]

I don’t want to speculate why such method does not exist, but if you like neither, perform a pre-test nor catch an exception, you need a re-implementation, e.g.

<pre><code>public static OptionalInt parseInt(String s) {
 if(s.isEmpty()) return OptionalInt.empty();
 final int len = s.length(), limit;
 final boolean negative;
 int i = 0;
 switch(s.charAt(0)) {
 case '-':
 i=1;
 if(len==1) return OptionalInt.empty();
 negative = true;
 limit = Integer.MIN_VALUE;
 break;
 case '+':
 i=1;
 if(len==1) return OptionalInt.empty();
 // fall-through
 default:
 negative = false;
 limit = -Integer.MAX_VALUE;
 }
 final int limitBeforeMul = limit / 10;
 int result = 0;
 for(; i &lt; len; i++) {
 int digit = Character.digit(s.charAt(i), 10);
 if(digit &lt; 0 || result &lt; limitBeforeMul || (result *= 10) &lt; limit + digit)
 return OptionalInt.empty();
 result -= digit;
 }
 return OptionalInt.of(negative? result: -result);
}
</code></pre>

This basically does the same as <code>Integer.parseInt</code>, but returns an empty <code>OptionalInt</code> for invalid strings instead of throwing an exception…

As you might notice, the hardest part is to handle numbers close to <code>Integer.MIN_VALUE</code> resp. <code>Integer.MAX_VALUE</code> correctly.

blocks|key|7686|text|谷歌的番石榴库提供了一个帮助方法来实现这一点:当字符串不可解析时，Ints.tryParse(+string+).It运行null。您可以查看文档。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|7687|entityMap|0|LINK|mutability|MUTABLE|url|https://guava.dev/releases/18.0/api/docs/com/google/common/primitives/Ints.html#tryParse(java.lang.String))^0|1P|4|1Z|2|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

Google's Guava library provides a helper method to do this: Ints.tryParse(String).It runs <code>null</code> when the string is not parsable. You can checkout the <a href="https://guava.dev/releases/18.0/api/docs/com/google/common/primitives/Ints.html#tryParse(java.lang.String)" rel="nofollow noreferrer">documentation</a>.

blocks|key|7283|text|使用兵变，可以这样编写它。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|7284|如果你只想用结果做一些事情，你可以用一个表达式来做。|7285|Uni.createFrom()
++.item(()+->+Integer.parseInt(toParse))
++.onFailure().recoverWithItem(defaultValue)
++.subscribe().with(i+->+System.out.println(i));|code-block|syntax|javascript|7286|或者创建一个类似于预期的方法|7287|++++public+static+Integer+parseIntOrDefault(String+toParse,+int+defaultValue)+{
++++++++Integer[]+toReturn+=+new+Integer[]{null};
++++++++Uni.createFrom()
+++++++++++.item(()+->+Integer.parseInt(toParse))
+++++++++++.onFailure().recoverWithItem(defaultValue)
+++++++++++.subscribe().with(i+->+toReturn[0]+=+i);
++++++++return+toReturn[0];
}|7288|这个解决方案添加了一个库，但是lib并不是专门处理这个问题的。它使用了反应性编程，期货，回调和一个流利的API，并证明是足够灵活的解决这个问题。|7289|entityMap|0|LINK|mutability|MUTABLE|url|https://smallrye.io/smallrye-mutiny/^0|2|2|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|13|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|15|8|@]|9|@]|C|$I|J]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

Using <a href="https://smallrye.io/smallrye-mutiny/" rel="nofollow noreferrer">Mutiny</a> it can be written like this.
If you just want to do something with the result you could do it in a single expression
<pre><code>Uni.createFrom()
 .item(() -&gt; Integer.parseInt(toParse))
 .onFailure().recoverWithItem(defaultValue)
 .subscribe().with(i -&gt; System.out.println(i));
</code></pre>
Or create a method like the one intended
<pre><code> public static Integer parseIntOrDefault(String toParse, int defaultValue) {
 Integer[] toReturn = new Integer[]{null};
 Uni.createFrom()
 .item(() -&gt; Integer.parseInt(toParse))
 .onFailure().recoverWithItem(defaultValue)
 .subscribe().with(i -&gt; toReturn[0] = i);
 return toReturn[0];
}
</code></pre>
This solution adds a library, but the lib is not specific to handle this problem. It uses reactive programing, futures, callbacks and a fluent API and proves to be flexible enough to solve this problem.

Is there a better way to try to convert to int a string that can be or not an integer?
Integer.parseInt(String value) will work well with &quot;25&quot; or &quot;019&quot; but not with &quot;hello&quot; or &quot;8A&quot;.
In Java 8, we have optional values, for example:
<pre><code>public static void main(String[] args) {
 Optional&lt;Integer&gt; optionalResult = functionThatReturnsOptionalInteger();
 Integer finalValue = optionalResult.orElse(0);
 System.out.println(finalValue);
}

public static Optional&lt;Integer&gt; functionThatReturnsOptionalInteger() {
 Integer[] ints = new Integer[0];
 return Stream.of(ints).findAny();
}
</code></pre>
You do not need to check nulls, because the <code>Optional</code> wrapper expose useful methods to deal with this kind of situations.
But if you want to <code>parseInt</code> a string, that can be null, or does not contains a valid integer, the solution is the same as always:
<pre><code>public static Integer parseIntOrDefault(String toParse, int defaultValue) {
 try {
 return Integer.parseInt(toParse);
 } catch (NumberFormatException e) {
 return defaultValue;
 }
}
</code></pre>
How can improve this with Java 8 features, why Integer.parseInt() has not been overloaded to return an Optional in case of bad argument? (Or just add a new method Integer.parseIntOptional() to Integer wrapper)

Way to parseInt without try-catch in Java 8?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

是否有更好的方法来尝试转换为整数的字符串？Integer.parseInt(字符串值)可以很好地处理"25“或"019”，而不是"hello“或"8A”。在Java 8中，我们有可选的值，例如：public static void main(String[] args) { Optional<Integer> o...

问在Java 8中不尝试捕获到parseInt的方法？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java 8中不尝试捕获到parseInt的方法？EN