在 Java 8 中没有 try-catch 的 parseInt 方法？

Question

有没有更好的方法来尝试将一个可以是或不是整数的字符串转换为 int？ Integer.parseInt(String value) 适用于“25”或“019”，但不适用于“hello”或“8A”。 在 Java 8 中，我们有可选值，例如：

public static void main(String[] args) {
    Optional<Integer> optionalResult = functionThatReturnsOptionalInteger();
    Integer finalValue = optionalResult.orElse(0);
    System.out.println(finalValue);
}

public static Optional<Integer> functionThatReturnsOptionalInteger() {
    Integer[] ints = new Integer[0];
    return Stream.of(ints).findAny();
}

您不需要检查空值，因为Optional 包装器公开了处理这种情况的有用方法。

但是如果你想parseInt一个字符串，那可以为null，或者不包含有效的整数，解决方法和往常一样：

public static Integer parseIntOrDefault(String toParse, int defaultValue) {
    try {
        return Integer.parseInt(toParse);
    } catch (NumberFormatException e) {
        return defaultValue;
    }
}

如何使用 Java 8 功能改进这一点，为什么 Integer.parseInt() 没有被重载 以 return an Optional 以防参数错误？ （或者只是将一个新方法 Integer.parseIntOptional() 添加到 Integer 包装器）

Answer 1

与其他答案现在已删除不同，我认为这与 Java 向后兼容并不真正有关。

因为一个空的Optional 代表一个不存在的值，这意味着该方法实际上有效，但没有返回任何结果。

但是，将hello 解析为整数将不起作用并且必须抛出异常，因为这是一个错误，而不是一个空结果。请记住，NumberFormatException 扩展了 IllegalArgumentException。

更一般地说，Optional 用于处理可能不存在的值（而不是使用null），而不是用于错误处理。此外，Optional 没有提供任何方法来了解错误是什么以及为什么会出现错误。

Answer 2

在标准库 afaik 中不存在类似的东西，但您可以编写一个将 String 解析为 Optional<Integer> 的方法，如下所示：

public static Optional<Integer> parseInt(String toParse) {
    try {
        return Optional.of(Integer.parseInt(toParse));
    } catch (NumberFormatException e) {
        return Optional.empty();
    }
}

Answer 3

Google 的 Guava 库提供了一个辅助方法来执行此操作：Ints.tryParse(String)。它在字符串不可解析时运行 null。您可以查看documentation。

Answer 4

没有 try-catch 并且仍然返回 Optional - 你可以这样做

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

编辑：更新正则表达式以支持负数

警告：正如 cmets 中所指出的，如果解析的字符串超出 Integer.MIN_VALUE 和 Integer.MAX_VALUE 的范围，仍会抛出 RuntimeException

Answer 5

我不想推测为什么这种方法不存在，但如果你都不喜欢，执行预测试或捕获异常，你需要重新实现，例如

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 < len; i++) {
        int digit = Character.digit(s.charAt(i), 10);
        if(digit < 0 || result < limitBeforeMul || (result *= 10) < limit + digit)
            return OptionalInt.empty();
        result -= digit;
    }
    return OptionalInt.of(negative? result: -result);
}

这与Integer.parseInt 基本相同，但是对于无效字符串返回一个空的OptionalInt 而不是抛出异常……

您可能会注意到，最困难的部分是处理接近Integer.MIN_VALUE 的数字。 Integer.MAX_VALUE 正确。

Answer 6

使用Mutiny可以这样写。

如果你只想对结果做一些事情，你可以用一个表达式来做

Uni.createFrom()
  .item(() -> Integer.parseInt(toParse))
  .onFailure().recoverWithItem(defaultValue)
  .subscribe().with(i -> System.out.println(i));

或者创建一个像预期的方法

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

此解决方案添加了一个库，但该库并非专门用于处理此问题。它使用反应式编程、futures、回调和流畅的 API，并被证明足够灵活来解决这个问题。