一、Lambda 表达式

1. 概念

Lambda表达式是一个匿名函数，没有函数名。

2. 作用

在运行时，动态的定义一个方法，让定义方法变得简单，方法变成变量，随时可以替换

public class LambdaDemo {public static void main(String[] args) {MathOperation s = (int a, int b) -> a * b;System.out.println(s.operation(14, 2));// lambda 既是一个实现，也是一个对象，普通接口实现类，需要new实例化enact((str) -> System.out.println(str), "hello");// 方法引用InterfaceLambda str = System.out::println;str.doSomeShit("interface");}public static void enact(InterfaceLambda lambda, String s) {lambda.doSomeShit("lambda");System.out.println(s);}
}interface MathOperation {int operation(int a, int b);default int operation2(int a, int b) {return 0;}
}interface InterfaceLambda {void doSomeShit(String str);
}

3. 函数签名

返回参数 + 函数名 + 参数类型的列表  

4. 常见写法

4.1 不需要参数，返回值为5:   () -> 5

4.2 接收一个参数(数字类型，返回2倍) x -> 2*x

4.3 接收两个参数，并返回他们的差 (x,y) -> x-y

4.4 接收2个int型整数，返回他们的和 (int x,int y) - x + y

4.5 接收一个string对象，并在控制台答应 (String s) -> System.out.print(s)

// Java 7 
public Interface MyLambdaInterface {void doSomething(String s);
}public MyInterfactImpl implements MyLambadInterface {@Overridepublic void doSomething(String s){System.out.printIn(s);}
}MyLambdaInterface a = new MyInterfactImpl();// Java 8 这种写法的要求是接口必须只有一个方法，如果接口必须要多个方法，可以声明为default方法，运行时会生成匿名内部类
MyLambdaInterace m = (s) -> System.out.printIn(s);

5. 函数式接口 @FunctionalInterface

     Predicate<T>  有参数，有条件判断

     Function<T,R>  有参数，有返回值

    Consumer<T>  有参数，无返回值

    Supplier<T>   无参数、有返回值

二、Stream

1. Java 实现接口多继承用&

public class StreamDemo< T extends Serializable&Comparable >{}

2. 概念：Stream(流)是一个来自数据源的元素队列并支持聚合操作

• 元素：特定类型的对象，行程一个队列。Java中的Stream并不会存储元素，而是按需计算。
• 数据源：流的来源。可以是集合，数组，I/O channel，产生器generator等。
• 聚合操作：类似SQL语句一样的操作，比如filter，map，reduce,find,match,sorted等。
• 和以前的Collection操作不同，Stream操作还有两个基础的特征
  • Pipelinging：中间操作都会返回流对象本身。这样多个操作可以串联成一个管道，如同流式风格。这样做可以对操作进行优化，比如延迟执行和短路。
  • 内部迭代：以前对集合遍历都是通过Iterator或者for-each的方式，显示的在集合外部进行迭代，这叫作外部迭代。Stream提供了内部迭代的方式，通过访问者模式实现。通过内部的方式只要循环一次，就解决所有问题。

3. Stream操作

中间操作：

1. 选择与过滤

filter(Predicate p) 接收Lambda，从流中排除某些元素。

distinct()筛选，通过流所生成的元素的hashCode()和equal()去除重复元素

limit(Long maxsize)截断流，使其元素不超过给定数量。

skip(long n)跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流。

2. 映射

map(Function f)接收lambda，将元素转换成其它形式或提取信息；接收一个函数作为参数，该函数会被应道到每一个元素上，并将其映射成一个新的元素。

mapToDouble(ToDoubleFunction f)接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的DoubleStream。

mapToInt(ToIntFunction f)接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的IntStream。

mapToLong(ToLongFunction f)接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的LongStream。

flatMap(Function f)接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有的流连成一个流

3. 排序

sorted() 产生一个新流，其中按自然顺序排序

sorted(Comparator comp)产生一个新流，其中按比较器的规则排序

终止操作

1. 查找与匹配

        allMatch - 检查是否匹配所有元素

        anyMatch - 检查是否至少匹配一个元素

        noneMatch - 检查是否没有匹配的元素

        findFirst - 返回第一个元素

        findAny - 返回当前流中的任意元素

        count - 返回流中元素的总个数

        max - 返回流中最大值

        min - 返回流中最小值

2. 规约 reduce，需要初始化（类比Map - Reduce）

3. 收集Collect

        toList List<T> 把流中元素收集到List

        toSet Set<T> 把流中元素收集到Set

        toCollection Collection<T> 把流中元素收集到创建的集合

        count 计算流中元素的个数

        summaryStatistics 统计最大最小平均值

4. 迭代 forEach

Stream 代码

public class StreamDemo {public static void main(String[] args) {List<Integer> list = Arrays.asList(2, 3, 4, 21, 33, 2, 2);// Optional ：stream中间操作返回封装类，防止空指针Optional<Integer> first = list.stream().findFirst();// orElse: 如果是空，给默认值100sSystem.out.println(first.map(i -> i * 10).orElse(100));// reduce： 需要给一个初始值0，依次相加，如果是乘法，初始值要改成1int sum = list.stream().filter((x) -> x < 5).distinct().reduce(0, (a, b) -> a + b);System.out.println(sum);// MapMap<Integer, Integer> map = list.parallelStream().collect(Collectors.toMap(a -> a, a -> a + 1, (a, b) -> a, HashMap::new));System.out.println(map);List<Integer> list1 = map.entrySet().parallelStream().map(e -> e.getKey() + e.getValue()).collect(Collectors.toList());System.out.println(list1);System.out.println(list.stream().map(e -> e + 1).collect(Collectors.toList()));}
}