Java8 Stream流

Path path = Paths.get("D:\\home\\src\\main\\resources");
try {
    // 找到指定path下的所有的文件
    Stream<Path> stream = Files.list(path);
    // TODO: 对流对象做处理
} catch (IOException e) {
    e.printStackTrace();
}

Path path = Paths.get("D:\\home\\src\\main\\resources");
try {
    // 第二个参数用于指定遍历几层
    Stream<Path> stream = Files.walk(path, 2);
    // TODO: 对流对象做处理
} catch (IOException e) {
    e.printStackTrace();
}

Path path = Paths.get("D:\\home\\src\\main\\resources");
try {
    // 找到指定path下的所有不是目录的文件
    Stream<Path> stream = Files.find(path, 2, (path1, basicFileAttributes) -> {
        // 过滤掉目录文件
        return !basicFileAttributes.isDirectory();
    });
    // TODO: 对流对象做处理
} catch (IOException e) {
    e.printStackTrace();
}

Path path = Paths.get("D:\\home\\src\\main\\resources");
try {
    // 找到指定path下的所有不是目录的文件
    Stream<Path> stream = Files.find(path, 2, (path1, basicFileAttributes) -> {
        // 过滤掉目录文件
        return !basicFileAttributes.isDirectory();
    });
    // TODO: 对流对象做处理
} catch (IOException e) {
    e.printStackTrace();
}

Stream<Integer> ofSteam = Stream.of(1,2,3,4,5,6);

/**
 * Collector是专门用来作为Stream的collect方法的参数的
 *
 * 泛型含义
 * T：是流中要收集的对象的泛型
 * A：是累加器的类型，累加器是在收集过程中用于累积部分结果的对象。
 * R：是收集操作得到的对象(通常但不一定是集合)的类型。
 */
public interface Collector<T, A, R> {
    /**
     * 生成结果容器，容器类型为A
     * (多线程的情况下可能会调用多次,开多个线程同时去处理一个流，每个线程调用一次)
     */
    Supplier<A> supplier();

    /**
     * A对应supplier()函数创建的结果容器
     * T对应Stream流里面一个一个的元素
     * 用于消费元素，也就是归纳元素，一般在这个里面把流里面的元素T(也可以转换下)放到supplier()创建的结果T里面去
     */
    BiConsumer<A, T> accumulator();

    /**
     * 用于两个两个合并并行执行的线程的执行结果，将其合并为一个最终结果A
     * 多线程的情况下，多个线程并行执行。每个线程产生一个结果
     */
    BinaryOperator<A> combiner();

    /**
     * 用于将之前整合完的结果A转换成为R
     *
     * combiner()完成之后了A, 这里还可以在转一道。生成你自己想要的结果
     */
    Function<A, R> finisher();

    /**
     * characteristics表示当前Collector的特征值，
     * 这是个不可变Set
     * 它定义了收集器的行为--尤其是关于流是否可以多线程并行执行，以及可以使用哪些优化的提示
     */
    Set<Characteristics> characteristics();

    /**
     * 它定义了收集器的行为--尤其是关于流是否可以并行归约，以及可以使用哪些优化的提示
     */
    enum Characteristics {
        /**
         * accumulator函数可以从多个线程同时调用，且该收集器可以并行归约流。如果收集器没有标为UNORDERED,
         * 那它仅在用于无序数据源时才可以并行归约
         * 多线程并行
         */
        CONCURRENT,

        /**
         * 归约结果不受流中项目的遍历和累积顺序的影响(无序)
         */
        UNORDERED,

        /**
         * 无需转换结果
         */
        IDENTITY_FINISH
    }


    /**
     * 四参方法，用于生成一个Collector，T代表流中的一个一个元素，R代表最终的结果
     */
    public static<T, R> Collector<T, R, R> of(Supplier<R> supplier,
                                              BiConsumer<R, T> accumulator,
                                              BinaryOperator<R> combiner,
                                              Characteristics... characteristics);

    /**
     * 五参方法，用于生成一个Collector，T代表流中的一个一个元素，A代表中间结果，R代表最终结果，finisher用于将A转换为R
     */
    public static<T, A, R> Collector<T, A, R> of(Supplier<A> supplier,
                                                 BiConsumer<A, T> accumulator,
                                                 BinaryOperator<A> combiner,
                                                 Function<A, R> finisher,
                                                 Characteristics... characteristics);



}

// 自己来组装Collector，返回一个List
@Test
public void collectNew() {
    Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    List<Integer> intList = stream.collect(
            new Collector<Integer, List<Integer>, List<Integer>>() {
                // 生成结果容器，容器类型为,我们这里为List<Integer>
                @Override
                public Supplier<List<Integer>> supplier() {
                    return new Supplier<List<Integer>>() {

                        @Override
                        public List<Integer> get() {
                            return new ArrayList<>();
                        }
                    };
                }

                // 把流里面的结果都放到结果容器里面去
                @Override
                public BiConsumer<List<Integer>, Integer> accumulator() {
                    return new BiConsumer<List<Integer>, Integer>() {
                        @Override
                        public void accept(List<Integer> integers, Integer integer) {
                            integers.add(integer);
                        }
                    };
                }

                // 两个两个合并并行执行的线程的执行结果，将其合并为一个最终结果A
                @Override
                public BinaryOperator<List<Integer>> combiner() {
                    return new BinaryOperator<List<Integer>>() {
                        @Override
                        public List<Integer> apply(List<Integer> left, List<Integer> right) {
                            left.addAll(right);
                            return left;
                        }
                    };
                }

                // 可以对最终的结果做一个转换操作
                @Override
                public Function<List<Integer>, List<Integer>> finisher() {
                    return new Function<List<Integer>, List<Integer>>() {
                        @Override
                        public List<Integer> apply(List<Integer> integers) {
                            return integers;
                        }
                    };
                }

                // 特征值
                @Override
                public Set<Characteristics> characteristics() {
                    return EnumSet.of(Collector.Characteristics.UNORDERED, Collector.Characteristics.IDENTITY_FINISH);
                }
            });

    for (Integer item : intList) {
        System.out.println(item);
    }
}