Java--8--新特性--Lambda

Posted 2020-10-15

java9 都出来了，我才开始接触到java8的新特性，有点脱节啊。。

Lambda是一个匿名函数，可以理解为一段可以传递的代码，将代码像数据一样传递，下面是一个小例子。

public class Employee
{
    private String name;
    private int age;
    private int salary;
//getter and setter
}
//-----------------------------------------------
public interface MyInter {
     Boolean filter(Employee list);
}
//-----------------------------------------------
public class MyInterImpl implements  MyInter {
    @Override
    public Boolean filter(Employee list) {
        return list.getage()>35;
    }
}
//-----------------------------------------------
package LambdaP;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class LamBdaDemo {

    public static final List<Employee> employees = Arrays.asList(
            new Employee("张三", 19, 2000),
            new Employee("张四", 33, 3000),
            new Employee("张五", 38, 4000),
            new Employee("张六", 41, 2500),
            new Employee("张七", 42, 5500)
    );

    //需求：当前公司中员工的年冷大于三十五的员工信息
    //传统方法
    public List<Employee> getEmployees() {
        List<Employee> list = new ArrayList<>();
        for (Employee employee : employees) {
            if (employee.getage() > 35) {
                list.add(employee);
            }
        }
        return list;
    }

    public void test1() {
        List<Employee> employees = this.getEmployees();
        for (Employee e : employees) {
            System.out.println(e);
        }
    }

    //方法2
    public  List<Employee> filterEmployee(List<Employee> list,MyInter inter){
        List<Employee> newlist = new ArrayList<>();
        for (Employee employee : list) {
            if(employee.getage()>35){
                newlist.add(employee);
            }
        }
        return newlist;
    }
    public  void test2(){
        List<Employee> employees = this.filterEmployee(LamBdaDemo.employees, new MyInterImpl());
        for (Employee employee : employees) {
            System.out.println(employee);
        }
    }
    //Lambda
    @Test
    public void test3(){
        List<Employee> employees = this.filterEmployee(LamBdaDemo.employees, (e) -> e.getage() > 35);
        for (Employee employee : employees) {
            System.out.println(employee);
        }
        System.out.println("Lambda .....");
    }
    //方法三：如果以上的都不存在的话   Stream API  也是在java8中新更新的
    @Test
    public void test4(){
        employees.stream().filter((e)->e.getage()>35).forEach(System.out::println);
    }
}

以上就能看出来Lambda的便捷性，下面开始我自己的学习笔记

import org.junit.Test;
import java.util.Comparator;
import java.util.function.Consumer;

public class LamBdaDemo2 {
    /**
     * Lambda的基本语法：java8中新引入了“->”操作符，简称箭头操作符或者Lambda操作符，
     *                  他将Lambda表达式拆分成两部分
     *                          1. 左侧：对应Lambda的参数列表
     *                          2. 右侧：Lambda所要执行的功能，”Lambda体“
     *                  箭头操作符的左侧对应接口中的参数列表，右侧即所要实现的方法。
     *         JDK 1.7 之前内部类引用同级的外部变量必须加final，现在不用手动加，默认，但是还是在内部类中不能操作外部变量，Lambda中同样适用。
     * 语法格式一：无参数，无返回值   test1
     *           （）-> System.out.println("Hello");
     * 语法格式二：有一个参数，无返回值 test2
     *           （e）-> { 实现 };
     * 语法格式三：有两个以上个参数，并且Lambda体有多条语句，有返回值。 test3
     *           (x,y)->{ 实现 };
     * 语法格式四：Lambda 表达式的参数列表类型可以省略不写，如果写就必须全部写，JVM可以自己推断出参数类型。
     *             Comparator<Integer> comparator2 = (Integer x,Integer y) ->   Integer.compare(x,y);
     *
     *          左右遇一括号省    ：即Lambda体重左右两边如果只有一个参数或者一条语句的话括号可以省略不写。
     *          左侧推断类型省    ：JVM自己推断出来
     *
     * Lambda表达式需要“函数式接口的支持”
     *          函数式接口：若接口中只有一个抽象方法的接口叫做函数式接口
     *          用Ctrl加左击点击接口名可以查看系统提供的接口是否为函数式接口
     *          系统提供的函数式接口都加有  @FunctionalInterface  注解
     *          此注解可以检查是否是函数式接口
     */


    public  void test1(){
        Runnable runnable1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello");
            }
        };
        runnable1.run();
        System.out.println("*********************");
        Runnable runnable = ()-> System.out.println("Hello Lambda");
        runnable.run();
    }
    public  void test2(){
        //consumer 定义  @FunctionalInterface
        //                public interface Consumer<T> {

        //Consumer 中的方法  void accept(T t);
        Consumer<String> consumer = (e) -> System.out.println("Lambda " + e);
        consumer.accept("Hello");

        //在只有一个参数的情况下小括号是可以省略不写的
        Consumer<String> con = e -> System.out.println("Lambda " + e);
        con.accept("Hello");
    }
    public  void test3(){
        Comparator<Integer> comparator = (x,y) ->{
            System.out.println("比较x y");
            return Integer.compare(x,y);
        };
        System.out.println(comparator.compare(1,2));

        System.out.println("**************************");
        //如果如上只有一条语句后面的大括号  可以省略不写
        Comparator<Integer> comparator2 = (x,y) ->   Integer.compare(x,y);
        int compare = comparator2.compare(2, 1);
        System.out.println(compare);
    }
}

下面来实现一个小功能：对两个数的任意操作

@FunctionalInterface
public interface MyInter2 {
     Integer getValue(Integer x);
}