Stream流操作

stream流操作

public class Streams {

    private enum Status{
        OPEN,CLOSE
    };

    private static final class Task{
        private final Status status;
        private final Integer points;

        Task( final Status status, final Integer points ) {
            this.status = status;
            this.points = points;
        }

        public Integer getPoints() {
            return points;
        }

        public Status getStatus() {
            return status;
        }

        @Override
        public String toString() {
            return String.format( "[%s, %d]", status, points );
        }
    }

    /**
     * Stream操作测试：stream操作分为：中间操作，例如filter()仍然返回一个Stream；
     * 晚期操作，例如sum()、forEach()，这些操作会遍历stream获取结果，在执行晚期操作以后
     * stream处理线程处理完毕
     * @see Collection#stream()
     * @see java.util.stream.Stream#filter(Predicate)
     * @desc 这里Task::getPoints方法引用和task->task.getPoints效果相同
     */
    @Test
    public void streamTest(){
        final Collection<Task> tasks = Arrays.asList(
                new Task(Status.OPEN,5),
                new Task(Status.OPEN,13),
                new Task(Status.CLOSE,8)
        );
        final long totalPoints = tasks.stream()
                .filter(task -> task.getStatus().equals(Status.OPEN))
                .mapToInt(Task::getPoints)
                .sum();
        System.out.println("totalPoints:" + totalPoints);
    }
}

并行处理

/**
 * java8另一特性：创造性支持了并行处理（parallel processing）
 * 这里使用parallel方法并行处理所有task，并用reduce方法计算出最终结果
 * 
 * @see Stream#parallel()
 * @see Stream#reduce(Object, BinaryOperator)
 */
@Test
public void parallelProcessTest(){
    final Collection<Task> tasks = Arrays.asList(
            new Task(Status.OPEN,5),
            new Task(Status.OPEN,13),
            new Task(Status.CLOSE,8)
    );
    final long totalPoints = tasks.stream()
            .parallel()
            .map(task -> task.getPoints())
            .reduce(0,Integer::sum);
    System.out.println("totalPoints:" + totalPoints);
}