如何使用 Java API Streams 执行此类操作？答案

【问题标题】：How to perform such operations using Java API Streams?如何使用 Java API Streams 执行此类操作？
【发布时间】：2017-12-29 02:36:09
【问题描述】：

我想在一个流上连续执行以下操作。

1)。我想创建一个从2 到n 的数字流。

我想这可以这样完成：IntStream.range(2, n)。

2)。添加过滤器，仅当该数字不能被已通过此过滤器的任何其他数字整除时，该数字才会更进一步。

我无法实现这样的过滤器。我想我必须创建一个包含ArrayList 的匿名类，并且我会将通过此过滤器的所有数字存储在此ArrayList 中。这一切都应该是这样的：

IntStream.range(2, n).filter(new IntPredicate() {
        ArrayList<Integer> prev;

        @Override
        public boolean test(int value) {
            if (prev == null) {
                prev = new ArrayList();
                return true;
            }
            for (int i = 0; i < prev.size(); i++) {
                if (value % prev.get(i) == 0) {
                     return false;
                }
            }
            prev.add(value);
            return true;
        }

3)。获取Map<Integer, Integer>，其中键是数百个（即 100、200、300、400 等），值是每百个中的素数个数。因此，对于一百个 100，我必须找到 [100, 199] 范围内的素数个数。

我想很明显，在第二步之后，流中只剩下素数了。但是我不知道如何执行第三步，也不确定第二步的实现。

您能帮我正确应用所有操作吗？

【问题讨论】：

流并不是非常适合这个。不是真正适合这项工作的工具。

标签： java java-8 java-stream

【解决方案1】：

假设你有一个方法isPrime(int)（你可以很容易地在网上找到一个实现），下面是你如何对结果进行分组：

IntStream.range(2, n)
        .filter(i -> isPrime(i))
        .boxed()
        .collect(Collectors.groupingBy(i -> i / 100 * 100,
                Collectors.summingInt(i -> 1)))

【讨论】：

如果这个数字不能被已经通过这个过滤器的任何其他数字整除，那么这个答案就不是它的解决方案。我了解 OP 无法正确指定其问题（至少是模棱两可的）。
@Jean-BaptisteYunès 这只是一个素数。有什么问题？
如果输入不是从 2 到 n 的整数范围，那么他的规范没有定义素数。
@Jean-BaptisteYunès 输入？什么输入？
从 2 到 n 的整数范围

【解决方案2】：

我稍微修改了你的代码，因为如果你在循环中检查 prev null，它会得到错误的 IntStream。

您可以运行代码来检查结果。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.function.IntPredicate;
import java.util.function.Supplier;
import java.util.stream.IntStream;

public class StreamAPI {

    public static void main(String[] args) {

        int n = 1000;
        Supplier<IntStream> intStreamSupplier = () -> IntStream.range(2, n).filter(new IntPredicate() {

            ArrayList<Integer> prev = new ArrayList<>();

            @Override
            public boolean test(int value) {

                for ( int i = 0; i < prev.size(); i++ )
                {
                    if ( value % prev.get(i) == 0 )
                    {
                        return false;
                    }
                }
                prev.add(value);
                return true;
            }
        });

        Map<Integer, IntStream> map = new HashMap<>();

        for ( int i = 0; i < n; i += 100 )
        {
            int j = i;
            IntStream subStream = intStreamSupplier.get().filter(new IntPredicate() {

                @Override public boolean test(int value) {

                    if ( j < value && value < ( j + 100 ) )
                    {
                        return true;
                    }
                    return false;
                }
            });

            map.put(i, subStream);
        }

        for ( Map.Entry<Integer, IntStream> entry : map.entrySet() )
        {
            Integer key = entry.getKey();
            IntStream value = entry.getValue();

            System.out.println("key: " + key);
            int[] arr = value.toArray();
            for ( int i = 0; i < arr.length; i++ )
            {
                System.out.println(arr[i]);
            }
        }
    }
}

【讨论】：