Spliterator Java 8

Question

我有一个1到10,000的数字存储在long数组中。按顺序添加它们会产生50,005,000的结果 我编写了一个Spliterator，如果一个数组的大小超过1000，它将被拆分为另一个数组。 这是我的代码。但是当我运行它时，添加的结果远远超过50,005,000。有人能告诉我我的代码有什么问题吗？

非常感谢你。

import java.util.Arrays;
import java.util.Optional;
import java.util.Spliterator;
import java.util.function.Consumer;
import java.util.stream.LongStream;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

public class SumSpliterator implements Spliterator<Long> {

    private final long[] numbers;
    private int currentPosition = 0;

    public SumSpliterator(long[] numbers) {
        super();
        this.numbers = numbers;
    }

    @Override
    public boolean tryAdvance(Consumer<? super Long> action) {
        action.accept(numbers[currentPosition++]);
        return currentPosition < numbers.length;
    }

    @Override
    public long estimateSize() {
        return numbers.length - currentPosition;
    }

    @Override
    public int characteristics() {
        return SUBSIZED;
    }

    @Override
    public Spliterator<Long> trySplit() {
        int currentSize = numbers.length - currentPosition;

        if( currentSize <= 1_000){
            return null;
        }else{
            currentPosition = currentPosition + 1_000;
            return new SumSpliterator(Arrays.copyOfRange(numbers, 1_000, numbers.length));
        }
    }

    public static void main(String[] args) {

        long[] twoThousandNumbers = LongStream.rangeClosed(1, 10_000).toArray();

        Spliterator<Long> spliterator = new SumSpliterator(twoThousandNumbers);
        Stream<Long> stream = StreamSupport.stream(spliterator, false);

        System.out.println( sumValues(stream) );
    }

    private static long sumValues(Stream<Long> stream){
        Optional<Long> optional = stream.reduce( ( t, u) ->  t + u );

        return optional.get() != null ? optional.get() : Long.valueOf(0);
    }

}

Answer 1

我有强烈的感觉，你没有达到分裂正确的目的。它并不意味着复制基础数据，而只是提供对其中一系列数据的访问。请记住，分裂器提供只读访问权限。因此，您应该将原始数组传递给新的spliterator，并使用适当的位置和长度对其进行配置，而不是复制数组。

但除了复制效率低之外，逻辑显然是错误的：你将Arrays.copyOfRange(numbers, 1_000, numbers.length)传递给新的分裂器，所以新的分裂器包含从位置1000到数组末尾的元素而你将当前分裂器的位置提前1000，因此旧的分裂器覆盖从currentPosition + 1_000到阵列末尾的元素。因此，两个分裂器将覆盖阵列末尾的元素，同时，根据currentPosition的先前值，开头的元素可能根本不会被覆盖。因此，当您希望将currentPosition推进1_000时，跳过的范围将由Arrays.copyOfRange(numbers, currentPosition, 1_000)表示，而是在推进之前引用currentPosition 。< / p>

还应该注意，分词器应该尝试分割平衡，即，如果已知大小，则在中间。因此，拆分千元素并不是阵列的正确策略。

此外，您的tryAdvance方法错误。它不应该在调用消费者之后测试而在之前测试，如果没有更多元素则返回false，这也意味着消费者不< / em>被叫了。

总而言之，实施可能看起来像

public class MyArraySpliterator implements Spliterator<Long> {

    private final long[] numbers;
    private int currentPosition, endPosition;

    public MyArraySpliterator(long[] numbers) {
        this(numbers, 0, numbers.length);
    }
    public MyArraySpliterator(long[] numbers, int start, int end) {
        this.numbers = numbers;
        currentPosition=start;
        endPosition=end;
    }

    @Override
    public boolean tryAdvance(Consumer<? super Long> action) {
        if(currentPosition < endPosition) {
            action.accept(numbers[currentPosition++]);
            return true;
        }
        return false;
    }

    @Override
    public long estimateSize() {
        return endPosition - currentPosition;
    }

    @Override
    public int characteristics() {
        return ORDERED|NONNULL|SIZED|SUBSIZED;
    }

    @Override
    public Spliterator<Long> trySplit() {
        if(estimateSize()<=1000) return null;
        int middle = (endPosition + currentPosition)>>>1;
        MyArraySpliterator prefix
                           = new MyArraySpliterator(numbers, currentPosition, middle);
        currentPosition=middle;
        return prefix;
    }
}

但是，当然，建议尽可能提供专门的forEachRemaining实施：

@Override
public void forEachRemaining(Consumer<? super Long> action) {
    int pos=currentPosition, end=endPosition;
    currentPosition=end;
    for(;pos<end; pos++) action.accept(numbers[pos]);
}

作为最后一点，对于从数组中求长项的任务，首选Spliterator.OfLong和LongStream并且已完成工作，请参阅Arrays.spliterator()和{{ 3}}，使整个任务像Arrays.stream(numbers).sum()一样简单。