9102年了，你还在用for循环操作集合？

// 对苹果按颜色汇总并绩数量
Map<String, Long> appleCount = apples.stream()
    .collect(groupingBy(Apple::getColor, counting()));
// 过滤掉颜色为黑色的苹果，并汇总好苹果的总金额
Double sum = apples.stream()
    .filter(i->"black".equals(i.getColor()))
    .collect(toList);

// 普通函数
public void run(String s){
    System.out.print(s+"哈哈");
}
// 我不要名字啦！！！
(s)->System.out.print(s+"哈哈")

// 实现Runnable中的run方法，替代匿名内部类。
Runnable r = ()->System.out.print("哈哈");
// 作为参数传递。
new Thread(()-> System.out.println("haha")).start();

ArrayList<Apple> list = new ArrayList<>();
list.forEach(i-> System.out.println(i.getWeight()));


// 简化策略模式
public static List<Apple> filterApples(List<Apple> inventory,ApplePredicate p){
    List<Apple>  apples = new ArrayList<>();
    for(Apple apple : inventory){
        if(p.test(apple)){
            apples.add(apple);
        }
    }
    return apples;
}
public class BigApple implement ApplePredicate{
    @Override
    public boolean test(Apple a){
        if(a.getWeight>10){
            return a
        }
    }
}
// 这是个简单的策略模式，根据用户的需要，创建不同的接口ApplePredicate实现类,调用时传入不同的实现类就可以，但问题是如果需求过多，创建的实现类也会很多，过于臃肿不方便管理。
xx.filterApple(inventory,new BigApple);
// 使用lambda表达式，不在需要创建BigApple类
xx.filterApple(inventory,i->(i.getWeight>10));

方法出参入参来自函数式接口
//入参s,返回void
(s)->System.out.println(s);
//入参空，返回void
()->System.out.print("haha");
//入参i,返回i+1
i->i+1
//后面写代码块
apple->{if(apple.getWeiht>5) return "BIG";
        else return "small";
       }

List<Double> collect = list.stream()
        // 过滤掉黑色的苹果
        .filter(i -> "black".equals(i.getColor()))
        // 让苹果按照重量个价格排序
        .sorted(Comparator.comparing(Apple::getWeight)
                .thenComparing(i->i.getPrice()))
        // 筛选掉重复的数据
        .distinct()
        // 只要苹果的价格
        .map(Apple::getPrice)
        // 只留下前两条数据
        .limit(2)
        // 以集合的形式返回
        .collect(toList());
// 循环打印列表中元素
list.forEach(i->System.out.print(i));

List<String> strings = Arrays.asList("Hello", "World");
List<String> collect1 = strings.stream()
    // String映射成String[]
    .map(i -> i.split(""))
    // Arrays::Stream 数据数组，返回一个流String[]->Stream<String>
    // flatMap各数组并不分别映射成一个流，而是映射成流的内容 Stream<String>->Stream
    .flatMap(Arrays::stream)
    .collect(toList());
System.out.println(collect);
----->输出 [H, e, l, l, o, W, o, r, l, d]

List<Integer> integers = Arrays.asList(12, 3, 45, 3, 2,-1);
// 有初始值的叠加操作
Integer reduce = integers.stream().reduce(3, (i, j) -> i + j);
Integer reduce2 = integers.stream().reduce(5, (x, y) -> x < y ? x : y);
// 无初始值的叠加操作
Optional<Integer> reduce1 = integers.stream().reduce((i, j) -> i + j);
// 无初始值的最大值
Optional<Integer> reduce4 = integers.stream().reduce(Integer::min);
// 无初始值的最大值
Optional<Integer> reduce5 = integers.stream().reduce(Integer::max);
// 求和
Optional<Integer> reduce6 = integers.stream().reduce(Integer::sum);

// 数值流求平均值
OptionalDouble average = apples.stream()
        .mapToDouble(Apple::getPrice)
        .average();
// 数值流求和
OptionalDouble average = apples.stream()
    .mapToDouble(Apple::getPrice)
    .sum();
// 数值流求最大值，没有则返回2
double v = apples.stream()
    .mapToDouble(Apple::getPrice)
    .max().orElse(2);
// 生成随机数
IntStream s = IntStream.rangeClosed(1,100);