Java8 Stream流

public class Student {

    private String name; // 姓名
    private String sex; // 性别
    private int hight; // 身高

    public Student(String name, String age, int hight) {
        this.name = name;
        this.sex = age;
        this.hight = hight;
    }

    // Get And Set
    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getHight() {
        return hight;
    }

    public void setHight(int hight) {
        this.hight = hight;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name=‘" + name + ‘\‘‘ +
                ", sex=‘" + sex + ‘\‘‘ +
                ", hight=" + hight +
                ‘}‘;
    }
}

parallelStream() 使用多线程并发处理最后子啊汇总结果，而 stream() 是单线程。所以相对来说 parallelStream() 效率要稍微高点。

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

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

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

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

Stream 其他创建方式我们就不一一举例了。有如下方式。

• Random.ints()
• BitSet.stream()
• Pattern.splitAsStream(java.lang.CharSequence)
• JarFile.stream()
• ...

Stream 流终端操作是流式处理的最后一步，之前已经对 Stream 做了一系列的处理之后。该拿出结果了。我们可以在终端操作中实现对流的遍历、查找、归约、收集等等一系列的操作。

Stream 流终端操作提供的函数有。

关于 Stream 终端操作部分，我们就着重讲下 collect() 函数的使用。因为其他的终端操作符都很好理解。collect() 稍稍复杂一点。

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

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

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

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

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

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

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

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


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

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



}

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

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

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

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

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

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

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