2

我有一个从 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);
    }

}
4

1 回答 1

5

我有强烈的感觉，你没有得到正确的分裂目的。它并不是要复制底层数据，而只是提供对其中一部分的访问。请记住，拆分器提供只读访问权限。因此，您应该将原始数组传递给新的拆分器，并为其配置适当的位置和长度，而不是复制数组。

但是除了复制效率低之外，逻辑显然是错误的：你传递Arrays.copyOfRange(numbers, 1_000, numbers.length)给新的拆分器，所以新的拆分器包含从位置1000到数组末尾的元素，你将当前拆分器的位置提前 1000，所以旧的拆分器覆盖从currentPosition + 1_000数组到末尾的元素。因此，两个拆分器都将覆盖数组末尾的元素，同时，根据之前的值currentPosition，开头的元素可能根本不会被覆盖。所以当你想currentPosition通过1_000跳过的范围来表示前进时Arrays.copyOfRange(numbers, currentPosition, 1_000)，参考currentPosition 之前的前进。

还应该注意，拆分器应该尝试拆分平衡，也就是说，如果大小已知，则在中间。因此，拆分一千个元素并不是数组的正确策略。

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

把它们放在一起，实现可能看起来像

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

作为最后一点，对于从数组中求和 long 的任务，aSpliterator.OfLong和 aLongStream是首选，并且该工作已经完成，请参阅Arrays.spliterator()和LongStream.sum()，使整个任务像Arrays.stream(numbers).sum().

于 2015-07-22T16:04:15.807 回答