Spliterator是Java 8中加入的另一个新接口；这个名字代表“可分迭代器”（splitableiterator）。和Iterator一样，Spliterator也用于遍历数据源中的元素，但它是为了并行执行而设计的。

自定义Spliterator需要实现Spliterator接口。

Spliterator接口

public interface Spliterator<T> {
    boolean tryAdvance(Consumer<? super T> action);
    Spliterator<T> trySplit();
    long estimateSize();
    int characteristics();
}
1
2
3
4
5
6

• T：Spliterator遍历的元素的类型

• tryAdvance：类似于普通的Iterator，因为它会按顺序一个一个使用Spliterator中的元素，并且如果还有其他元素要遍历就返回true。

• trySplit：把一些元素划出去分给第二个Spliterator（由该方法返回），让它们两个并行处理。

• estimateSize：估计还剩下多少元素要遍历，让拆分均匀一点。

• characteristics

拆分过程

自定义

package com.morris.java8.parallel;

import java.util.Spliterator;
import java.util.function.Consumer;
import java.util.stream.IntStream;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

public class IntSpliterator implements Spliterator<Integer> {

    private int start;

    private int end;

    private int current;

    private int[] data;

    public Stream<Integer> stream() {
       return StreamSupport.stream(this, false);
    }

    public Stream<Integer> parallelStream() {
        return StreamSupport.stream(this, true);
    }

    public IntSpliterator(int[] data) {
        this(0, data.length, data);
    }

    public IntSpliterator(int start, int end, int[] data) {
        this.start = start;
        this.end = end;
        this.current = start;
        this.data = data;
    }

    @Override
    public boolean tryAdvance(Consumer<? super Integer> action) {

        if(current < end) {
            action.accept(data[current++]);
            return true;
        }
        return false;
    }

    @Override
    public Spliterator<Integer> trySplit() {

        if(start - end <= 2) {
            return null;
        }

        int mid=start+((end-start)/2);
        int newStart=mid;
        int newEnd=end;
        end=mid;
        return new IntSpliterator(newStart, newEnd, data);

    }

    @Override
    public long estimateSize() {
        return data.length - end;
    }

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

    public static void main(String[] args) {
        int[] ints = IntStream.rangeClosed(1, 10).toArray();
        IntSpliterator intSpliterator = new IntSpliterator(ints);

        intSpliterator.stream().forEach(System.out::println);
        //intSpliterator.parallelStream().forEach(System.out::print);

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82