JDK1.8之Lambda表达式

Lambda是jdk1.8新增的语法。可以把Lambda表达式理解为是一段可以传递的代码。使用它可以写出更简洁、更灵活的代码。

一、Lambda表达式

Lambda表达式：在Java8语言中引入的一种新的语法元素和操作符。操作符为“->”，该操作符被称为Lambda操作符或箭头操作符。它将Lambda分为两个部分：

• 左侧：指定了Lambda表达式需要的参数列表
• 右侧：指定了Lambda体，是抽象方法的实现逻辑，也即Lambda表达式要执行的功能。

双冒号（::）操作符是 Java 中的方法引用。 当们使用一个方法的引用时，目标引用放在 :: 之前，目标引用提供的方法名称放在 :: 之后，即 目标引用::方法。

二、Lambda表达式的结构

• 一个 Lambda 表达式可以有零个或多个参数
• 参数的类型既可以明确声明，也可以根据上下文来推断。例如：(int a)与(a)效果相同
• 所有参数需包含在圆括号内，参数之间用逗号相隔。例如：(a, b) 或 (int a, int b) 或 (String a, int b, float c)
• 空圆括号代表参数集为空。例如：() -> 42
• 当只有一个参数，且其类型可推导时，圆括号（）可省略。例如：a -> return a*a
• Lambda 表达式的主体可包含零条或多条语句
• 如果 Lambda 表达式的主体只有一条语句，花括号{}可省略。匿名函数的返回类型与该主体表达式一致
• 如果 Lambda 表达式的主体包含一条以上语句，则表达式必须包含在花括号{}中（形成代码块）。匿名函数的返回类型与代码块的返回类型一致，若没有返回则为空

三、具体示例代码

1.数组循环

List<Object> list2 = new ArrayList<>();
list2.add("中");
list2.add("人");
list2.add("好");
list2.add("去");
//方式一：
list2.forEach(System.out :: println);
//方式二：
list2.forEach(a -> {
    System.out.println("打印：" + a);
});

2.数组操作（交集、并集、差集、并集去重）

一、基本数值类型（不包含字符串类型）
List<Integer> list1 = new ArrayList<>();
list1.add(1);
list1.add(2);
list1.add(3);
list1.add(5);
list1.add(6);

List<Integer> list2 = new ArrayList<>();
list2.add(2);
list2.add(3);
list2.add(7);
list2.add(8);

test(list1,list2);

二、基本数值类型（包含字符串类型）
List<Object> list1 = new ArrayList<>();
list1.add("中");
list1.add("过");
list1.add("是");
list1.add("人");
list1.add("明");

List<Object> list2 = new ArrayList<>();
list2.add("中");
list2.add("人");
list2.add("好");
list2.add("去");


test1(list1,list2);

方法

通用方法
public static List<Object> test1(List<Object> list1, List<Object> list2){
    List<Object> intersection = list1.stream().filter(item -> list2.contains(item)).collect(toList());
    System.out.println("---交集 intersection---");
    intersection.parallelStream().forEach(System.out :: println);

    // 差集 (list1 - list2)        List<Object> reduce1 = list1.stream().filter(item -> !list2.contains(item)).collect(toList());
    System.out.println("---差集 reduce1 (list1 - list2)---");
    reduce1.parallelStream().forEach(System.out :: println);

    // 差集 (list2 - list1)
    List<Object> reduce2 = list2.stream().filter(item -> !list1.contains(item)).collect(toList());
    System.out.println("---差集 reduce2 (list2 - list1)---");
    reduce2.parallelStream().forEach(System.out :: println);

    // 并集
    List<Object> listAll = list1.parallelStream().collect(toList());
    List<Object> listAll2 = list2.parallelStream().collect(toList());
    listAll.addAll(listAll2);
    System.out.println("---并集 listAll---");
    listAll.parallelStream().forEachOrdered(System.out :: println);

    // 去重并集
    List<Object> listAllDistinct = listAll.stream().distinct().collect(toList());
    System.out.println("---得到去重并集 listAllDistinct---");
    listAllDistinct.parallelStream().forEachOrdered(System.out :: println);
    System.out.println("==============");
    return listAllDistinct;
}


public static List<? extends Number> test(List<? extends Number> list1, List<? extends Number> list2){
    List<? extends Number> intersection = list1.stream().filter(item -> list2.contains(item)).collect(toList());
    System.out.println("---交集 intersection---");
    intersection.parallelStream().forEach(System.out :: println);

    // 差集 (list1 - list2)
    List<? extends Number> reduce1 = list1.stream().filter(item -> !list2.contains(item)).collect(toList());
    System.out.println("---差集 reduce1 (list1 - list2)---");
    reduce1.parallelStream().forEach(System.out :: println);

    // 差集 (list2 - list1)
    List<? extends Number> reduce2 = list2.stream().filter(item -> !list1.contains(item)).collect(toList());
    System.out.println("---差集 reduce2 (list2 - list1)---");
    reduce2.parallelStream().forEach(System.out :: println);

    // 并集
    List<Object> listAll = list1.parallelStream().collect(toList());
    List<Object> listAll2 = list2.parallelStream().collect(toList());
    listAll.addAll(listAll2);
    System.out.println("---并集 listAll---");
    listAll.parallelStream().forEachOrdered(System.out :: println);

    // 去重并集
    List<Object> listAllDistinct = listAll.stream().distinct().collect(toList());
    System.out.println("---得到去重并集 listAllDistinct---");
    listAllDistinct.parallelStream().forEachOrdered(System.out :: println);
    System.out.println("==============");
    return reduce2;
}

里面还涉及到Stream API的概念，后面再单独总结。