Java8 新特性之Lambda 表达式

 Lambda 表达式的基础语法：

语法格式一： 无参数无返回值 () -> System.out.println("Hello Java8 Lambda!");

语法格式二：有一个参数无返回值 (x) -> System.out.println(x);

语法格式三：有一个参数，小括号可以省略不写 x -> System.out.println("x");

语法格式四：有两个以上参数，有返回值，并且Lambda 体中有多条语句，要使用 {} 包裹起来 （x, y）-> {System.out.println(x); System.out.println(y);}

语法格式五：若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写Comparator com = (x, y)-> Integer.compare(x, y);

语法格式六：若 Lambda 表达式中的数据类型可以省略不写，因为 JVM 编译器通过上下文推断出，数据类型即“类型推断”

简单的使用实例一：

简单的使用实例二：实现字符串的处理

简单的使用实例三：实现实现员工信息的筛选

个人心得

Lambda 表达式的基础语法：

    Java8 引入了一个新的操作符 "->" 称为箭头操作符或者Lambda 操作符，箭头操作符将 Lambda 拆分成两部分
 左侧： Lambda 表达式的参数列表
 右侧： Lambda 表达式中所需要执行的功能，即 Lambda 体
    
左右遇一括号省   ==> 左侧只有一个参数，() 可以省略，右侧只有一条语句时，{}可以省略
左侧推断类型省   ==> 由于参数类型 JVM 可以推断出来，所以左侧的参数类型可以不写
能省则省

语法格式一： 无参数无返回值 () -> System.out.println("Hello Java8 Lambda!");

package test2;

import org.junit.Test;

public class TestLambda2 {
    @Test
    public void test1() {
        int num = 0;

        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello Java8 Lambda! " + num);
            }
        };

        r1.run();
        System.out.println("---------------------------------------------");

        Runnable r2 = () -> System.out.println("Hello Java8 Lambda! "+ num);
        r2.run();
    }
}

语法格式二：有一个参数无返回值 (x) -> System.out.println(x);

@Test
public void test2(){
    Consumer con = (x) -> System.out.println(x);
    con.accept("Java Lambda is so powerful!");
}

语法格式三：有一个参数，小括号可以省略不写 x -> System.out.println("x");

@Test
public void test2(){
    Consumer con = x -> System.out.println(x);
    con.accept("Java Lambda is so powerful!");
}

语法格式四：有两个以上参数，有返回值，并且Lambda 体中有多条语句，要使用 {} 包裹起来 （x, y）-> {System.out.println(x); System.out.println(y);}

@Test
public void test3(){
    Comparator com = (x, y)->{
        System.out.println("函数式接口");
        return Integer.compare(x, y);
    };
}

语法格式五：若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写Comparator com = (x, y)-> Integer.compare(x, y);

@Test
public void test4(){
    Comparator com = (x, y)-> Integer.compare(x, y);
}

语法格式六：若 Lambda 表达式中的数据类型可以省略不写，因为 JVM 编译器通过上下文推断出，数据类型即“类型推断”

Comparator com2 = (Integer x, Integer y)->Integer.compare(x, y);

简单的使用实例一：

对一个数进行简单的计算

1、首先写一个函数式的接口

@FunctionalInterface
public interface MyFun{
    public Integer getValue(Integer num);
}

2、将该接口变量和其要处理的变量类型共同作为参数，写一个实现方法

public Integer operation(Integer num, MyFun fun){
    return fun.getValue(num);
}

3、调用写好的函数，传入要处理的参数，接口变量写成 Lambda 表示式的形式

// 需求： 对一个数进行运算
@Test
public void test5(){
    Integer operation = operation(100, x -> x * x);
    System.out.println(operation);

    Integer operation1 = operation(200, y -> y + 200);
    System.out.println(operation1);
}

简单的使用实例二：实现字符串的处理

将字符串首位去掉空白字符、换成大写，字符串的截取

@FunctionalInterface
public interface MyFun {
    public String getValue(String str);
}

public String strHandler(String str, MyFun fun){
    return fun.getValue(str);
}

    
@Test
public void test2(){
    String handler = strHandler("ttn Java Lambda is very powerful!  ", str -> str.trim());
    System.out.println(handler);

    String handler1 = strHandler("ttn Java Lambda is very powerful!  ", str -> str.toUpperCase());
    System.out.println(handler1);

    String handler2 = strHandler("ttn Java Lambda is very powerful!  ", str -> str.substring(4, 33));
    System.out.println(handler2);
}

简单的使用实例三：实现 Long 类型数据的基础处理

@FunctionalInterface
public interface MyFun2 {
    public R getValue(T t1, T t2);
}

public void calculate(Long l1, Long l2, MyFun2 mf){
    System.out.println(mf.getValue(l1, l2));
}

@Test
public void test3(){
    calculate(100L, 200L, (x, y)->x+y);
    calculate(100L, 200L, (x, y)->x*y);
}

简单的使用实例三：实现员工信息的筛选

public class Employee {
    private String name;
    private Integer age;
    private Double salary;

    public Employee() {}

    public Employee(String name, Integer age, Double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Double getSalary() {
        return salary;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + ''' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }
}

// 需求，获取当前公司中员工年龄大于 35的员工信息
List employees = Arrays.asList(
        new Employee("zhangsan", 18, 4000.20),
        new Employee("lisi", 35, 17000.50),
        new Employee("wangwu", 28, 25000.80),
        new Employee("maliu", 40, 25000.60),
        new Employee("guaijiaoqi", 18, 4000.30)
);

 将员工按照年龄进行排序，如果年龄相同，按照姓名进行排序

@Test
public void test1(){
    Collections.sort(this.employees, (e1, e2)->{
        if(e1.getAge().equals(e2.getAge())){
            return e1.getName().compareTo(e2.getName());
        }else{
            return Integer.compare(e1.getAge(), e2.getAge());
        }
    });

    for(Employee employee: this.employees){
        System.out.println(employee);
    }
}

个人心得

感觉Lambda 对于单个数据的处理这么写反而变得繁琐，单个数据处理可以简单的多，Lambda 的优势是在于多个数据的处理上，比如像 List、Map 这样的数据处理上。

上述内容来自于视频笔记：【Java】Java8新特性-Lambda表达式-Stream API等_尚硅谷__李贺飞_哔哩哔哩_bilibili