标签: java-stream

如何在Java 8中查找以下列表中数字的最大值,最小值,总和和平均值？

List<Integer> primes = Arrays.asList(2, 3, 5, 7, 11, 13, 17, 19, 23, 29);

我有一种情况,我正在读取数据库并返回a List<String>,其中每个字符串被选中并根据某些条件添加到列表中.方法签名是:

public List<String> myMethod(String query, int limit)

第二个参数提供返回列表大小的上限(设置limit=-1将删除任何大小限制).为了避免使这个方法占用大量内存,我编写了一个返回Stream<String>而不是列表的等效方法.(注意:我不需要随机访问返回的元素或任何其他特定于列表的功能.)

但是,我对返回a有点怀疑Stream<>,特别是因为该方法是公开的.使用Stream<>Java 返回公共方法是否安全？

有谁知道时间的复杂性java.util.stream.Stream<T>.sorted()是什么？

当Java方法接受a时Function<? super T, ? extends U>,可以使用如下语法提供方法引用:MyClass::myMethod.

但是,我想知道是否有一种链接多个方法调用的方法.这是一个说明案例的例子.

// on a specific object, without lambda
myString.trim().toUpperCase()

我想知道是否有语法将其转换为lambda表达式.我希望有类似的东西:

// something like: (which doesn't work)
String::trim::toUpperCase

或者,是否有一个实用程序类来合并函数？

// example: (which does not exist)
FunctionUtil.chain(String::trim, String::toUpperCase);

我想知道我是否可以根据流之外的某种条件设置向流添加操作.例如,如果我的limit变量不等于,我想向流添加限制操作-1.

我的代码目前看起来像这样,但我还没有看到以这种方式使用流的其他示例,其中Stream对象被重新分配给应用于自身的中间操作的结果:

// Do some stream stuff
stream = stream.filter(e -> e.getTimestamp() < max);

// Limit the stream
if (limit != -1) {
   stream = stream.limit(limit);
}

// Collect stream to list
stream.collect(Collectors.toList());

如此stackoverflow帖子中所述,在调用终端操作之前,实际上不会应用过滤器.由于我在调用终端操作之前重新分配了流的值,上面的代码仍然是使用Java 8流的正确方法吗？

假设我有一个庞大的 Boolean数组flags:

Boolean[] flags = { true, false, true };    // 3 means "many"

我想做两件事flags:

• 检查所有元素是否都true返回并返回指标;
• 将所有元素重置为false.

使用Java 8的lambda表达式,我可以按如下方式执行:

indicator = Arrays.stream(flags).allMatch(flag -> flag);
Arrays.stream(flags).forEach(flag -> flag = false);
return indicator;

但是,此实现扫描flags两次.由于flags是巨大的,我不希望这样.另外,我更喜欢lambda方式.有没有办法checkIfAllTrueAndReset用(单行)lambda表达式实现这种语义,flags只扫描一次？

相关但不相同:检查布尔数组中的所有值是否为真的最优雅的方法是什么？

注意:我从评论和答案中学到了很多东西.谢谢你们!

1. Stream很酷,但不是这个.
2. BitSet(以及它的位原子对应物AtomicBitSet)更适合这种情况(因此被接受为答案;感谢其他人).
3. 不鼓励map(Stream或通常是函数式编程)的副作用.
4. Arrays.stream(flags).forEach(flag -> flag = false)(在我的代码中)没有设置任何东西!

for在大多数情况下,Java 8流允许的代码比旧式循环更具可读性.但是,根据我自己的经验和我所读到的内容,使用流而不是for循环可能会导致性能损失(或偶尔会有改进),有时难以预测.

在大型项目中,为每个循环编写基准测试似乎不可行,因此在决定是否for用流替换循环时,关键因素是什么(例如,预期的集合大小,预期的值删除百分比)过滤,迭代操作的复杂性,减少或聚合的类型等等,它们可能表明将导致的性能变化？

注意:这是我之前的问题的缩小,因为过于宽泛而关闭(并且并行流的各个方面在另一个SO问题中得到了很好的覆盖),所以让我们将其限制为顺序流.

从回答这个问题开始,我遇到了一个特殊的功能.下面的代码按照我的假设工作(现有数组中的前两个值将被覆盖):

Integer[] newArray = Stream.of(7, 8)
                           .parallel()
                           .toArray(i -> new Integer[] {1, 2, 3, 4, 5, 6});

System.out.println(Arrays.toString(newArray));

输出:

[7, 8, 3, 4, 5, 6]

但是,使用顺序流尝试此操作会抛出IllegalStateException:

Integer[] newArray = Stream.of(7, 8)
                           .toArray(i -> new Integer[] {1, 2, 3, 4, 5, 6});

System.out.println(Arrays.toString(newArray));

输出:

Exception in thread "main" java.lang.IllegalStateException: Begin size 2 is not equal to fixed size 6
    at java.base/java.util.stream.Nodes$FixedNodeBuilder.begin(Nodes.java:1222)
    at java.base/java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:483)
    at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:474)
    at java.base/java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:550)
    at java.base/java.util.stream.AbstractPipeline.evaluateToArrayNode(AbstractPipeline.java:260)
    at java.base/java.util.stream.ReferencePipeline.toArray(ReferencePipeline.java:517)
    at test/test.Test.main(Test.java:30)

我很好奇为什么顺序流不会像并行流那样覆盖数组的元素.我搜索了一下,无法找到有关此的文档,但我认为它存在于某处.

我对Java 8(仍在学习)并不熟悉,并希望看看我是否可以使用流找到与下面代码相同的东西.

下面的代码主要尝试为String中的每个值获取相应的double值,然后将其求和.在这种格式的任何地方我找不到多少帮助.我不确定使用流是否会清理代码或使其变得更加混乱.

// safe assumptions - String/List (Key/Value) cannot be null or empty
// inputMap --> Map<String, List<String>>

Map<String, Double> finalResult = new HashMap<>();
for (Map.Entry<String, List<String>> entry : inputMap.entrySet()) {
    Double score = 0.0;
    for (String current: entry.getValue()) {
        score += computeScore(current);
    }
    finalResult.put(entry.getKey(), score);
}

private Double computeScore(String a) { .. }

根据这个问题,我们可以修改源,它不称为干扰:

您可以修改流元素本身,不应将其称为"干扰".

根据这个问题,代码

List<String> list = new ArrayList<>();
  list.add("test");
  list.forEach(x -> list.add(x));

会扔ConcurrentModificationException.

但我的代码,

Employee[] arrayOfEmps = {
                new Employee(1, "Jeff Bezos"),
                new Employee(2, "Bill Gates"),
                new Employee(3, "hendry cavilg"),
                new Employee(4, "mark cuban"),
                new Employee(5, "zoe"),
                new Employee(6, "billl clinton"),
                new Employee(7, "ariana") ,
                new Employee(8, "cathre"),
                new Employee(9, "hostile"),
                new Employee(10, "verner"),
            };
        Employee el=new Employee(1, "Jeff Bezos");
        List<Employee> li=Arrays.asList(arrayOfEmps);
        li.stream().map(s->{s.setName("newname");return s;}).forEach(System.out::print);

ConcurrentModificationException即使它实际上改变了源,也不会抛出.

而这段代码,

Employee[] arrayOfEmps = {
                new Employee(1, "Jeff …