java-->lambda

import java.util.Arrays;
import java.util.DoubleSummaryStatistics;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

/**
 * 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
 * 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
 * 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
 * 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。
 */
public class LambdaTest {

    public static void main(String[] args) {
        //1.lambda 表达式代替匿名内部类
        System.out.println("1-----------------");
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("内部类写法");
            }
        }).start();

        new Thread(() -> System.out.println("lambda表达式")).start();

        //2.lambda表达式对列表进行迭代
        System.out.println("2-----------------");
        List<String> list = Arrays.asList("java","c++","python","go");
        list.forEach(n -> System.out.println(n));

        //3.使用lambda表达式和函数式接口Predicate
        System.out.println("3-----------------");
        List<String> list1 = Arrays.asList("java","c++","python","go");
        Predicate<String> p1 = (n)->n.startsWith("j");
        Predicate<String> p2 = (n)->n.length() >= 4;
        list1.stream().filter(p1).forEach(n-> System.out.println(n));
        list1.stream().filter(n->n.startsWith("j")).forEach(n-> System.out.println(n));

        //4.Predicate之多个过滤条件
        System.out.println("4-----------------");
        list1.stream().filter(p1.and(p2)).forEach(n-> System.out.println(n));
        list1.stream().filter(p1.or(p2)).forEach(n-> System.out.println(n));

        //5.lambda表达式之map
        System.out.println("5-----------------");
        List<Double> list2 = Arrays.asList(30.0,50.0,80.0,100.0);
        list2.stream().map(n->n*0.2).forEach(n-> System.out.println(n));

        //6.lambda表达式之reduce()
        System.out.println("6---------------------");
        System.out.println(list2.stream().map(n->n*0.2).reduce((sum,n)->sum+n).get());

        //7.lambda表达式之collect()
        System.out.println("7---------------------");
        List<Double> result = list2.stream().filter(n->n>=50).collect(Collectors.toList());
        result.forEach(n-> System.out.println(n));

        //8.lambda表达式之distinct()去重
        System.out.println("8---------------------");
        List<String> list3 = Arrays.asList("java","c++","python","go","java","c++","python","go","go");
        List<String> result2 = list3.stream().filter(n->n.startsWith("j")).distinct().collect(Collectors.toList());
        result2.forEach(n-> System.out.println(n));

        //9.计算集合元素的最大值，最小值等
        System.out.println("9---------------------");
        DoubleSummaryStatistics result3 = list2.stream().mapToDouble(n->n).summaryStatistics();
        System.out.println(result3.getMax());
        System.out.println(result3.getMin());
        System.out.println(result3.getSum());
        System.out.println(result3.getAverage());
        System.out.println(result3.getCount());//个数

        //10.lambda表达式有个限制，那就是只能引用 final 或 final 局部变量，这就是说不能在lambda内部修改定义在域外的变量。

        System.out.println("10---------------------");
        int aa = 0;
        //list2.forEach(n-> System.out.println(aa++)); //Error:(79, 46) java: 从lambda 表达式引用的本地变量必须是最终变量或实际上的最终变量
    }

}

1-----------------
内部类写法
2-----------------
lambda表达式
java
c++
python
go
3-----------------
java
java
4-----------------
java
java
python
5-----------------
6.0
10.0
16.0
20.0
6---------------------
52.0
7---------------------
50.0
80.0
100.0
8---------------------
java
9---------------------
100.0
30.0
260.0
65.0
4
10---------------------