Java 8

Question

我在long的数组中存储了一个从1到10,000的数字。当将它们按顺序相加时，会得到50,005,000的结果。
我编写了一个拆分器，如果一个数组的大小大于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

我强烈地感觉到你没有达到分裂的目的。它不是要复制底层数据，而是提供对其范围的访问。请记住，拆分器提供只读访问。所以您应该将原始数组传递给新的拆分器，并将其配置为适当的位置和长度，而不是复制数组。

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

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

此外，您的tryAdvance方法是错误的。它不应该在调用使用者之后而在调用之前进行测试，如果没有更多的元素，则html" target="_blank">返回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;
    }
}

但当然，建议在可能的情况下提供专门的foreachlething实现：

@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()和longstream.sum()，使整个任务与arrays.stream(numbers).sum()一样简单。