一篇文章读懂java8新特性（lambda、stream）用法

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Optional;
import java.util.function.Predicate;
import java.util.function.ToIntFunction;

/**
 * @author songfengjie
 * @version 1.0
 */
public class Streams {
    
    public static void main(String[] args) {
        final Collection<Task> tasks = Arrays.asList(
            new Task(Status.OPEN, 5),
            new Task(Status.OPEN, 13),
            new Task(Status.CLOSED, 8) 
        );
        
        System.out.println("tasks=="+tasks);
        
        //java8新语法写法
        final long totalPointsOfOpenTasks1 = tasks
            .stream()
            .filter(task -> task.getStatus() == Status.OPEN)
            .mapToInt(Task::getPoints)
            .sum();
        
        //java8常规的写法
        final long totalPointsOfOpenTasks2 = tasks
            .stream()
            .filter(new Predicate<Task>() {
                @Override
                public boolean test(Task t) {
                   if(t.getStatus() == Status.OPEN) {
                       return true;
                   }
                   return false;
                }
            })
            .mapToInt(new ToIntFunction<Task>() {
                @Override
                public int applyAsInt(Task value) {
                    return value.getPoints();
                }
            })
            .sum();
        
        //java8之前的写法
        int num = 0;
        for(Task task:tasks) {
            if(task.getStatus()==Status.OPEN) {
                num = num+ task.getPoints();
            }
        }
        
        System.out.println("Total points3: "+num);

        System.out.println("Total points1: " + totalPointsOfOpenTasks1);
        
        System.out.println("Total points2: " + totalPointsOfOpenTasks2);
        
        //判空+求和
        Optional.ofNullable(tasks).orElse(null).stream().mapToInt(Task::getPoints).sum();
        
        Optional.ofNullable(tasks).orElse(null).forEach(System.out::println);
        
        String num1 = null;
        List<Integer> num2 = new ArrayList<Integer>(); //java8之后可以不用写明final修饰词，视为隐性final修饰
        Optional.ofNullable(tasks).orElse(null).forEach(task->{//判空+增强for循环
            if(task.getStatus()==Status.OPEN) {
                //这里不可以给外部变量赋值
                //（因为在内部类中，引用外部变量需要外部变量被final修饰，而被final修饰的变量不可改变变量的堆地址，故不能给Sting、int等变量赋值，却可以给对象set、add值）
                // 至于为什么内部类引用的外部变量一定需要final修饰：
                   // 首先，内部类和外部类其实是处于同一个级别,反编译中可以看到都是对象级别的类文件，内部类不会因为定义在方法中就会随着方法的执行完毕而跟随者被销毁。
                   // 问题就来了，如果外部类的方法中的变量不定义final，那么当外部类方法执行完毕的时候，这个局部变量肯定也就被GC了，然而内部类的某个方法还没有执行完，
                   // 这个时候他所引用的外部变量已经找不到了。如果定义为final，java会将这个变量复制一份作为成员变量内置于内部类中(反编译class文件中可以看到)，
                   // 这样的话，由于final所修饰的值始终无法改变，所以这个变量所指向的内存区域就不会变。
                //num1 = task.getPoints().toString();  
                num2.add(task.getPoints());
            }
        });
    }
    

    private enum Status {
        OPEN, CLOSED
    };

    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 );
        }
    }
}