动态 Integer 参数
指的是 vararg ？

reduce

@Leviathann 就是调一次这个方法可以传入 N 个 Integer

```
@Test
public void test022() {
System.out.println(count(1, 2, 3, 4, 5));
}

public int count(int... input) {
return Arrays.stream(input).sum();
}
```
这个可以吗

静态就自己加个 static

你是来白嫖代码的吧

@BiChengfei 差不多了 ，你这个差一个非空效验，可以写

return Arrays.stream(input).mapToInt(n -> (n != null ? n : 0)).sum();

这个应该算挺优了

少了并行计算

@godleon 入参用的 int ，不可能为 null

@BiChengfei 需求就是 Integer

public static void main(String[] args) {
System.out.println(sum(1,2,4,null,3,5));
}
public static int sum(Integer ... number) {
return Stream.of(number).filter(Objects::nonNull).reduce(0, Integer::sum);
}

@godleon 基本类型自动拆箱，方法入参你可以写成 Integer
count(new Integer(1), new Integer(2), new Integer(3))

@gitdoit 老哥稳

public static int sumInt(@Nullable Integer @NotNull ... ints) {
var sum = 0;
for (var it : ints) {
if (it != null) {
sum += it;
}
}
return sum;
}

如果只有 null ，我是说 Integer[] arr = null; 的情况
所有上来就用 stream 的必报错，让你们优雅，哈哈哈

@anzu 那为什么不反思下 null 时候要调呢，接口定义可以协定不处理 null 的。
这到底是调用者还是被调用者的问题？

@anzu 什么意思，vararg 哪来的 null?

方法几百种，没有什么最优的，只有最适合你的自己的，可能你写的这个别人认为这里不行，别人写的你认为那里不行，每个人有每个人的写作风格。

？现在 Java 普及了 Babel 类似物了么？不卡源语言版本的？
（要能用 transpiler 一般也是全体 JVM 语言，用不着特指 Java 。）

fun sum(vararg array: Int?): Int {
return array.filterNotNull().fold(0) { acc, i -> acc + i }
}

accuracy 的值越大，精确度越高

public static long sum(Integer ... numbers) throws InterruptedException {
long accuracy = 1000L;
long startTime = System.currentTimeMillis();
for (Integer number : numbers) {
Thread.sleep(number * accuracy);
}
return (System.currentTimeMillis() - startTime) / accuracy;
}

kotlin 对 Int 的集合做了优化，直接这样就行

fun sum(vararg array: Int?): Int {
return array.filterNotNull().sum()
}

IntStream.of(1, 2, 3).filter(Objects::nonNull).sum()

fun sum(vararg array: Int?): Int {
return array.sumOf { it?:0 }
}

List<Integer> objects = Lists.newArrayList();
objects.stream().filter(Objects::nonNull).mapToInt(Integer::intValue).sum();

private static int sum(Integer... i){
return Arrays.stream(i).filter(Objects::nonNull).mapToInt(x -> x).sum();
}

@Leviathann 你好，有可能为 null 的

for 循环效率最高

import java.util.Objects._
def sum(ints:Int *):Int = ints.filter(nonNull).sum

sum(1,2,3,4)

<script src="https://scastie.scala-lang.org/TPI4eIIsQmukOvwOzh0FSQ.js"></script>

def sum(ints:Int *):Int =
(for(intValue <- ints if intValue ne null) yield intValue).sum

我记得阿里巴巴 java 开发手册里面有这么一句话，调用者应该负责参数的校验，谁调用谁负责，所以有 null 应该由调用者处理吧

def sum(ints:Integer *):Int =
ints.foldLeft(0)((a, b) => if (b eq null) a else a + b)

@Cbdy void func(Integer ...args) { System.out.println(args.toString()); }

直接 func() 调用都没问题，args 不可能为 null ，怎么导致 stream 报错

如果是直接传一个 null 参数，那在调用的地方就爆了和函数里面用什么方法处理也没关系

public static BigInteger sum(Integer ... ints) {
BigInteger sum = BigInteger.ZERO;
for (Integer anInt : ints) {
if (anInt != null) {
sum = sum.add(BigInteger.valueOf(anInt));
}
}
return sum;
}

@Leviathann 你确定？这里输出 args is null 后报错

public class MyClass {
public static void main(String args[]) {
Integer[] arr = null;
func(arr);
}
static void func(Integer ...args) {
if (args == null) {
System.out.println("args is null");
}
System.out.println(args.toString());
}
}

@anzu 的确 我看走眼了，回去翻了下 jshell 运行记录，由于函数体偷懒没写，而调用时那一长串文字原来是警告不是异常，
再次说明 2022 年还在使用一门连空安全都做不到的语言实在是浪费生命

@Leviathann 36L 给出了可能为 null 的情况，我在 14L 给给出了我的答案，你可以注意一下到我加的两个注解

至此，没有我认同的最佳答案，相反都是最差的回答。最优不等于语法糖。

public static int sum(Integer num, Integer... nums) {
int result = num == null ? 0 : num;
for (int i = 0; i < (nums == null ? 0 : nums.length); i++) {
result += sum(nums[i]);
}
return result;
}

@privatetan 人家问个问题就白嫖了？

代码不会写，但 采纳 这词不是这样用的吧

@douyacai911 你不要不识抬举

你们能不能加个 Markdown 代码格式

mapToInt(x -> x).sum() 比 reduce(0, Integer::sum) 好
mapToInt(Integer::intValue) 比 mapToInt(x -> x) 好
filter(Objects::nonNull) 比 n != null ? n : 0 好
sum(Integer ... numbers) 比 sum(Integer num, Integer... nums) 好, 因为过滤 null 后的加法是阿贝尔群, 允许无参返回单位元很合理
不考虑参数数组为 null 比数组为 null 返回 0 好
循环比一定比 stream 好, 因为 stream 可以方便地使用多线程

@aguesuka "循环比一定比 stream 好" -> "循环不一定比 stream 好"

@douyacai911 #42 应该笑纳

什么牛鬼蛇神的评论区

@Saxton 每个人有每个人的风格不错，但是在绝对的实力面前你的风格显得黯然失色！

@Saxton 我觉得代码的风格应该是一些样式问题，不应该是程序的代码的设计问题，确保程序的流畅运行，有时候你不得不放弃你的风格 选择可以达到效率最高的代码