如何使用Java API流执行此类操作？

Question

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

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等），而value是每百个素数的数量。 因此，对于100我必须找到在[100，199]范围内的质数。

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

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

Answer 1

假设您有一个方法isPrime(int) （可以轻松地在线找到实现），则可以将结果分组：

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

Answer 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]);
            }
        }
    }
}