Java 映射时我可以减少吗？

我需要转换命令行参数和它们的总和

public static void main(final String... args) {
    final int[] array = Arrays.stream(args).mapToInt(arg -> {
            try {
                return Integer.parseInt(arg);
            } catch (final NumberFormatException nfe) {
                System.err.println("wrong arg: " + arg);
            }
        }).toArray();
    final int total = IntStream.of(array).sum();
}

在映射时，我是否可以实际减少（

total

）

无论如何，我需要

array

和

total

。

为什么不这样做：

final int total = Arrays.stream(args).mapToInt(arg -> {
        try {
            return Integer.parseInt(arg);
        } catch (final NumberFormatException nfe) {
            System.err.println("wrong arg: " + arg);
        }
    }).sum();

资料来源：

为什么不这样做：

final int total = Arrays.stream(args).mapToInt(arg -> {
        try {
            return Integer.parseInt(arg);
        } catch (final NumberFormatException nfe) {
            System.err.println("wrong arg: " + arg);
        }
    }).sum();

资料来源：
有两种方法： 在开始时使用流求和：

 int sum =Arrays.stream(args).mapToInt(arg -> {
            try {
                return Integer.parseInt(arg);
            } catch (final NumberFormatException nfe) {
                System.err.println("wrong arg: " + arg);
                return 0;
            }
        }).sum();
        System.out.print(sum);

在处理过程中计算或求和：

    int sum[] =new int[1];

    Arrays.stream(args).mapToInt(arg -> {
        try {
             return Integer.parseInt(arg);
        } catch (final NumberFormatException nfe) {
            System.err.println("wrong arg: " + arg);
            return 0;
        }
    })
            .peek(value-> sum[0]+=value)
            .toArray();
    System.out.print(sum[0]);

但是第二种选择看起来不太好，我不鼓励你这么做。
有两种方法： 在开始时使用流求和：

 int sum =Arrays.stream(args).mapToInt(arg -> {
            try {
                return Integer.parseInt(arg);
            } catch (final NumberFormatException nfe) {
                System.err.println("wrong arg: " + arg);
                return 0;
            }
        }).sum();
        System.out.print(sum);

在处理过程中计算或求和：

    int sum[] =new int[1];

    Arrays.stream(args).mapToInt(arg -> {
        try {
             return Integer.parseInt(arg);
        } catch (final NumberFormatException nfe) {
            System.err.println("wrong arg: " + arg);
            return 0;
        }
    })
            .peek(value-> sum[0]+=value)
            .toArray();
    System.out.print(sum[0]);

---

但是第二个选项看起来不太好，我不鼓励你这么做。
你正在寻找

对

或

元组

，遗憾的是Java不支持这一点，也许你可以试试，这里有一个例子使用

对

：

    ImmutablePair<Integer, List<Integer>> res = Arrays.stream(strings).map(arg -> {
        try {
            return Integer.parseInt(arg);
        } catch (final NumberFormatException nfe) {
            System.err.println("wrong arg: " + arg);
            throw nfe;
        }
    }).reduce(ImmutablePair.of(0, new ArrayList<Integer>()), (pair, integer) ->
    {
        pair.getRight().add(integer);
        return ImmutablePair.of(pair.getLeft() + integer, pair.getRight());
    }, (pair1, pair2) -> {
        pair1.getRight().addAll(pair2.getRight());
        return ImmutablePair.of(pair1.getLeft() + pair2.getLeft(), pair1.getRight());
    });

ImmutablePair res=Arrays.stream（strings.map）（arg->{
试一试{
返回整数.parseInt（arg）；
}捕获（最终编号格式异常nfe）{
System.err.println（“错误参数：+arg”）；
投掷nfe；
}
}).reduce（ImmutablePair.of（0，new ArrayList（）），（pair，integer）->
{
pair.getRight（）.add（整数）；
返回ImmutablePair.of（pair.getLeft（）+整数，pair.getRight（））；
}，（对1，对2）->{
pair1.getRight（）.addAll（pair2.getRight（））；
返回ImmutablePair.of（pair1.getLeft（）+pair2.getLeft（），pair1.getRight（））；
});

您正在寻找

Pair

或

Tuple

，遗憾的是Java不支持这一点，也许您可以尝试一下，这里有一个使用

reduce

和

Pair

的示例：

    ImmutablePair<Integer, List<Integer>> res = Arrays.stream(strings).map(arg -> {
        try {
            return Integer.parseInt(arg);
        } catch (final NumberFormatException nfe) {
            System.err.println("wrong arg: " + arg);
            throw nfe;
        }
    }).reduce(ImmutablePair.of(0, new ArrayList<Integer>()), (pair, integer) ->
    {
        pair.getRight().add(integer);
        return ImmutablePair.of(pair.getLeft() + integer, pair.getRight());
    }, (pair1, pair2) -> {
        pair1.getRight().addAll(pair2.getRight());
        return ImmutablePair.of(pair1.getLeft() + pair2.getLeft(), pair1.getRight());
    });

ImmutablePair res=Arrays.stream（strings.map）（arg->{
试一试{
返回整数.parseInt（arg）；
}捕获（最终编号格式异常nfe）{
System.err.println（“错误参数：+arg”）；
投掷nfe；
}
}).reduce（ImmutablePair.of（0，new ArrayList（）），（pair，integer）->
{
pair.getRight（）.add（整数）；
返回ImmutablePair.of（pair.getLeft（）+整数，pair.getRight（））；
}，（对1，对2）->{
pair1.getRight（）.addAll（pair2.getRight（））；
返回ImmutablePair.of（pair1.getLeft（）+pair2.getLeft（），pair1.getRight（））；
});

反正我需要

数组

和

总计

。反正我需要

数组

和

总计

。@SamTebbs33我相信这是因为我们需要从lambda表达式内部更改值。你不能在lmbda内部传递可变属性，它是最终的，所以有一个古老的小技巧，这允许修改lambda之外的变量。但正如我所说的，这是非常不需要的。@Beri它会不会太多？这违反了干净的代码原则。Lambda表达式不应修改其主体之外的任何内容，当您使用流时，可能会导致错误，其次，此流是单线程的，但如果流并行运行，则您的值可能无法预测，由于缺乏同步性。@SamTebbs33我认为这是因为我们需要从lambda表达式内部更改值。您不能在lmbda内部传递可变属性，它是最终的，因此有一个来自旧时代的小技巧，允许修改lambda之外的变量。但正如我所说的，这是非常不需要的。@Beri它会不会太过了？这违反了干净的代码原则。Lambda表达式不应修改其主体之外的任何内容，当您使用流时，可能会导致错误，其次，此流是单线程的，但如果流并行运行，则由于缺少同步，您的值可能无法预测。您的代码无法编译。如果不返回值，则无法捕获函数中的异常。除此之外，不惜一切代价一步到位是没有意义的。结果将比仅仅获取数组并对数组执行简单的求和操作更复杂，并且很难预测是否会有性能差异以及在哪个方向上。您的代码不会编译。如果不返回值，则无法捕获函数中的异常。除此之外，不惜一切代价一步到位是没有意义的。结果将比仅仅获取数组并对数组执行一个简单的求和操作更复杂，并且是否会有性能差异以及在哪个方向上很难预测。