Java方法签名：流与集合与var arg

对于Java 8 Lambda/Closure，var arg方法签名是否有一种通用的最佳方法

在将方法与单个对象作为参数或对象集合一起使用的情况下，我看到了实现这一点的三个选项：

 private void optionOneVararg(String... params) { ... }
 private void optionTwoCollection(Collection<String> params) { ... }
 private void optionThreeStream(Stream<String> params) { ... }

private void optionononevararg（字符串…参数）{…}
私有void optionTwoCollection（集合参数）{…}
私有void optionTreestream（流参数）{…}

String类显然被用作示例

是否有一种普遍有效的“最佳实践”方法？vararg方法产生了Java7之前最流畅的代码。有了溪流，感觉很笨拙

---

我希望能够在方法内部和调用它的外部使用lambdas的便利性。此外，我希望尽量减少包装/粘贴代码（例如，

Collections.singletonList（element）

或

Arrays.asList（element）

），并避免使用

Collection myCollection=stream.collect（…）

后跟

myCollection.stream（）

通过调用，您仍然可以在方法中使用

流

API和lambdas。在这种情况下，您可以使用varargs保留签名：

private void optionVarArgs(String... params) {
   Stream.of(params)...
   ...
}

---

由于AR.3s的回答，我意识到保持

流作为一个参数在性能和美学方面都是优越的：

private void callOptionThreeFromStream() {
    List<String> foo = Arrays.asList(new String[] { "a", "b", "c" });
    Stream<String> stream = foo.stream();
    // use stream here
    optionThreeStream(stream);
}
private void callOptionThreeFromObject() {
    String bar = "a";
    optionThreeStream(Stream.of(bar)); //very simple conversion
}
private void optionThreeStream(Stream<String> params) {
    // use the same stream (and possibly profit from optimization)
}

private void callOptionThreeFromStream（）{
listfoo=Arrays.asList（新字符串[]{“a”、“b”、“c”}）；
Stream=foo.Stream（）；
//在这里使用流
选择Treestream（stream）；
}
私有void callOptionThreeFromObject（）{
字符串bar=“a”；
OptionTreestream（Stream.of（bar））；//非常简单的转换
}
私有void optionTreestream（流参数）{
//使用相同的流（并可能从优化中获益）
}

使用vararg参数会导致更多开销（至少在美学上）：

private void callOptionOneFromStream（）{
listfoo=Arrays.asList（新字符串[]{“a”、“b”、“c”}）；
Stream=foo.Stream（）；
//在这里使用流
optionNovararg（stream.toArray（String[]：：new））；//仍然笨拙
}
私有void callOptionOneFromObject（）{
字符串bar=“a”；
optionNovararg（bar）；//但这里是最佳的
}
私有void选项novararg（字符串…参数）{
Stream=Stream.of（参数）；
//在新创建的数组上使用新流
}

为了完整起见：

private void callOptionTwoFromStream() {
    List<String> foo = Arrays.asList(new String[] { "a", "b", "c" });
    Stream<String> stream = foo.stream();
    // use stream here
    optionTwoCollection(stream.collect(Collectors.toList())); //clumsy
}
private void callOptionTwoFromObject() {
    String bar = "a";
    optionTwoCollection(Collections.singletonList(bar)); //clumsy
}
private void optionTwoCollection(Collection<String> params) {
    Stream<String> stream = params.stream();
    // use the new stream on the newly created collection
}

private void calloptiontworomstream（）{
listfoo=Arrays.asList（新字符串[]{“a”、“b”、“c”}）；
Stream=foo.Stream（）；
//在这里使用流
optionTwoCollection（stream.collect（Collectors.toList（））；//笨拙
}
私有void calloptiontworomobject（）{
字符串bar=“a”；
optionTwoCollection（Collections.singletonList（bar））；//笨拙
}
私有void optionWOCollection（集合参数）{
Stream=params.Stream（）；
//在新创建的集合上使用新流
}

我个人的结论是：对私有方法使用
Stream
。在公共API方法中保留var arg或集合可能更适合隐藏内部技术细节

这是一个很好的细节，
Stream.of
使用var-arg参数一次覆盖数组和单个对象。
您不喜欢vararg选项的哪些地方？在var-args主题上，您可能想看一看。@assylias当我在流上使用操作（例如过滤器）时，然后将结果传递给我的函数，然后对该参数使用更多的流操作，vararg数组需要收集第一个流，然后才能将其传递给函数。为什么不使用不同的参数选项重载该方法？就像Java API中的许多方法已经在做的一样？很好的提示。但是打电话的那一方呢？这看起来很难看：
stream.collect（Collectors.toList（））.toArray（新字符串[0]）
@SebastianH
stream.toArray（字符串[]::new）
stream.of（）
不使用varargs覆盖单个对象。（）

方法的

重载。看：非常好的接球！谢谢我并不关心代码中的这种微观优化，但你的问题读得很好。它还提供了另一个参数，用于在可用时将流移交给内部函数。
private void callOptionTwoFromStream() {
    List<String> foo = Arrays.asList(new String[] { "a", "b", "c" });
    Stream<String> stream = foo.stream();
    // use stream here
    optionTwoCollection(stream.collect(Collectors.toList())); //clumsy
}
private void callOptionTwoFromObject() {
    String bar = "a";
    optionTwoCollection(Collections.singletonList(bar)); //clumsy
}
private void optionTwoCollection(Collection<String> params) {
    Stream<String> stream = params.stream();
    // use the new stream on the newly created collection
}