Spliterator

class CustBook{
        private String name;

        public CustBook() {
        }

        public CustBook(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }


    @Test
    public void test2(){
        //spliterator()方法返回一个分隔符，该分隔符支持并行处理，但不提供并行处理
        Spliterator<CustBook> split1 = generateElements().spliterator();
        //使用分隔符进行尝试分割
        Spliterator<CustBook> split2 = split1.trySplit();

        Spliterator<CustBook> custBookSpliterator = split1.trySplit();

        System.out.println("before tryAdvance: {}" + split1.estimateSize());
        System.out.println("Characteristics {}" + split1.characteristics());
//        System.out.println(call(split1));
//        System.out.println(call(split2));
        System.out.println("after tryAdvance {}" + split1.estimateSize());
        System.out.println("after tryAdvance 2  {}" + split2.estimateSize());
        System.out.println("after tryAdvance 3  {}" + custBookSpliterator.estimateSize());

    }

    @Test
    public void test3(){
//        //spliterator()方法返回一个分隔符，该分隔符支持并行处理，但不提供并行处理
//        List<CustBook> custBooks = generateElements();
//        //只是获取了分割器，并未分割
//        Spliterator<CustBook> split1 = custBooks.spliterator();
//        System.out.println(call(split1));
//        System.out.println("=============");
//        custBooks.forEach(new Consumer<CustBook>() {
//            @Override
//            public void accept(CustBook custBook) {
//                System.out.println(custBook.getName());
//            }
//        });


//        //spliterator()方法返回一个分隔符，该分隔符支持并行处理，但不提供并行处理
//        List<CustBook> custBooks = generateElements();
//        //只是获取了分割器，并未分割
//        Spliterator<CustBook> split = custBooks.spliterator();
//        //已经分割
//        Spliterator<CustBook> split1 = split.trySplit();
//        System.out.println(call(split));
//        System.out.println("=============");
//        custBooks.forEach(new Consumer<CustBook>() {
//            @Override
//            public void accept(CustBook custBook) {
//                System.out.println(custBook.getName());
//            }
//        });


        //spliterator()方法返回一个分隔符，该分隔符支持并行处理，但不提供并行处理
        List<CustBook> custBooks = generateElements();
        //只是获取了分割器，并未分割
        Spliterator<CustBook> split = custBooks.spliterator();
        //已经分割
        Spliterator<CustBook> split1 = split.trySplit();
        //对第一部分继续进行分割，此时为三分，一份为500个，剩余两份分别为250个
        Spliterator<CustBook> split2 = split1.trySplit();
        System.out.println(call(split));
        System.out.println("=============");
        custBooks.forEach(new Consumer<CustBook>() {
            @Override
            public void accept(CustBook custBook) {
                System.out.println(custBook.getName());
            }
        });



    }


    public List<CustBook> generateElements() {
        return Stream.generate(() -> new CustBook("cust book"))
                .limit(1000)
                .collect(Collectors.toList());
    }

    public String call(Spliterator<CustBook> spliterator) {
        int current = 0;
        while (spliterator.tryAdvance(a -> a.setName("test name".concat("- add new name")))) {
            current++;
        }

        return Thread.currentThread().getName() + ":" + current;
    }

List总共有1000条数据，调用一次trySplit之后，将List分成了两部分，每部分500条数据。

注意，在tryAdvance调用之后，estimateSize变为0，表示所有的元素都已经被处理完毕。

再看一下这个Characteristics=16464，转换为16进制：Ox4050 = ORDERED or SIZED or SUBSIZED 这三个的或运算。

自定义实现Spliterator。重写4个方法 tryAdvance, trySplit, estimateSize和characteristics。tryAdvance函数：如果当前长度大于0，则在由startIndex定义的当前方法上调用“ accept”函数trySplit：根据endIndex,startIndex 两个值拆分 userrList列表。estimateSize：被返回列表studentList的大小。characteristics：返回NONNULL，即所有元素均为nonnull。

import java.util.List;
import java.util.Random;
import java.util.Spliterator;
import java.util.function.Consumer;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

public class MySplitorator implements Spliterator {

    private List<Integer> list;
    private int startIndex;
    private int endIndex;

    public MySplitorator(List<Integer> list) {
        this(list, 0, list.size());
    }

    public MySplitorator(List<Integer> list, int startIndex, int endIndex) {
        this.list = list;
        this.startIndex = startIndex;
        this.endIndex = endIndex;
    }

    @Override
    public boolean tryAdvance(Consumer action) {
        if (getSize() == 0){
            return false;
        }
        action.accept(list.get(startIndex));
        startIndex++;
        return true;
    }

    @Override
    public Spliterator trySplit() {
        //只有一个元素，则不可以分割
        if (getSize() <= 1){
            return null;
        }
        //多个元素
        int newStartIndex = 0;
        int newEndIndex = endIndex;
//        if (getSize() % 2 == 0){
//            newStartIndex = startIndex + (getSize() / 2);
//            this.endIndex = getSize() / 2;
//        } else {
//            newStartIndex = startIndex + (getSize() / 2) + 1;
//            this.endIndex = getSize() / 2;
//        }
        newStartIndex = startIndex + (getSize() / 2);
        this.endIndex = newStartIndex - 1;
        return new MySplitorator(list, newStartIndex, newEndIndex);
    }

    @Override
    public long estimateSize() {
        return endIndex - startIndex;
    }

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

    public int getSize(){
        return endIndex - startIndex;
    }


    public static void main(String[] args) {
        List<Integer> collect = Stream.generate(new Supplier<Integer>() {
            @Override
            public Integer get() {
                return new Random().nextInt(10);
            }
        }).limit(10).collect(Collectors.toList());

        StreamSupport.stream(new MySplitorator(collect), true).forEach(System.out::println);

    }
}