Java8 Lambda 表达式

🍉 Java 8 介绍

Java8是2014年发布的版本，是Java5以来具有革命性的版本。

Java 8的主要新语法特性如下：

1. Lambda表达式
   Lambda表达式使Java程序员能够编写更加简洁、易读和易维护的代码。它是一种匿名函数，可以将其作为参数传递给其他方法或函数。

2. 方法引用
   方法引用是指通过名称来引用现有的方法，从而让代码变得更简洁、易读和易于维护。Java 8中提供了四种不同的方法引用方式：静态方法引用、实例方法引用、构造器引用和超类方法引用。

3. 接口默认方法
   Java 8允许在接口中定义具体实现的默认方法，这样实现类就可以继承该方法的实现，避免了因为新增方法而导致向所有实现类迁移代码的麻烦。

4. 函数式接口
   函数式接口仅包含一个抽象方法的接口，它是Java 8中Lambda表达式的基础。Java 8中提供了许多常用的函数式接口，例如：Predicate、Function、Consumer等。

5. Stream API
   Stream API是Java 8中一个强大的工具，它允许程序员轻松处理集合数据。使用流API可以实现筛选、排序、映射、归约等操作，让代码更加简洁、易读和易于维护。

6. 时间API
   Java 8中引入了新的时间API，它提供了一种更好的方式来处理日期和时间。这个API包含多个类，可以用来处理日历、时间、时区和持续时间等问题。

7. Optional 类型
   Optional类型是一个容器对象，可以包含null或非null值。它为程序员提供一种优雅的方式来处理null检查，从而避免NullPointerException异常。

这些新语法都带来了很大的变化，使得Java编程更加简洁、高效、可读性强和易于维护。

🍉 Lambda 表达式

Lambda是 一个 匿名函数，我们可以把Lambda表达式理解为是 一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

🍅🍅 基础语法

Java8引入了一个新的操作符： ->，该操作符称为箭头操作符或 Lambda 操作符，箭头操作符将Lambda 表达式拆分为2部分：

1. 左侧：Lambda 表达式的 参数列表
2. 右侧：Lambda 表达式中 所执行的功能，即 Lambda 体

语法格式1：无参数，无返回值：

public class test {
    public static void main(String[] args) {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello World!");
            }
        };
        r.run();

        System.out.println("--------------------------------------");
        Runnable r1 = () -> System.out.println("Hello Lambda");
        r1.run();
    }
}

语法格式2：有一个参数，并且无返回值，小括号可省略不写，：

public class test {
    public static void main(String[] args) {
        Consumer<String> con = x -> System.out.println(x);
        con.accept("SNOW");
    }
}

语法格式3：有2个以上的参数，有返回值，并且Lambda体中有多条语句 ，有返回值

public class test {
    public static void main(String[] args) {
        Comparator<Integer> com = (x,y) -> {
            System.out.println("函数式接口");
            return Integer.compare(x,y);
        };
    }
}

语法格式4：若Lambda体中只有一条语句，return和大括号都可省略不写

public class test {
    public static void main(String[] args) {
        Comparator<Integer> com = (x,y) -> Integer.compare(x,y);
    }
}

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

Lambda表达式需要 函数式接口 的支持！（函数式接口：接口中只有一个抽象方法的接口，称为函数式接口，可以使用 @FunctionalInterface 修饰。）

🍅🍅 案例

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee {
    private String name;
    private int age;
    private Double salary;
}

public class test {
    public static void main(String[] args) {
        List<Employee> list = Arrays.asList(
                new Employee("1号", 25, 5000.0),
                new Employee("2号", 35, 3000.0),
                new Employee("3号", 35, 2000.0),
                new Employee("4号", 35, 8000.0),
                new Employee("5号", 65, 1000.0)
        );
        Collections.sort(list,(e1,e2)->{
            if (e1.getAge() == e2.getAge()){
                return e1.getName().compareTo(e2.getName());
            }else {
                // 倒序
                return -Integer.compare(e1.getAge(),e2.getAge());
            }
        });
        Iterator<Employee> iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

🍉 函数式接口

🍅🍅 内置的四大核心函数式接口

1. Consumer：消费型接口 void accept(T t);
2. Supplier：供给型接口 T get();
3. Function(T,R)：函数型接口 R apply(T t);
4. Predicate：断言型接口 boolean test(T t);

🍅🍅 案例

1. Consumer：消费型接口

@Test
public void test(){
    this.happy(1000,m -> {
        System.out.println("我消费了"+ m);
    });
}

public void happy(double money, Consumer<Double> con){
    con.accept(money);
}

2. Supplier：供给型接口

@Test
public void test(){
    List<Integer> numList = this.getNumList(5, () -> (int) (Math.random() * 100));
    for (Integer integer : numList) {
        System.out.println(integer);
    }
}

//产生指定数量的整数
public List<Integer> getNumList(int num, Supplier<Integer> sup){
    List<Integer> list = new ArrayList<>();
    for (int i = 0; i < num; i++) {
        list.add(sup.get());
    }
    return list;
}

3. Function(T,R)：函数型接口

@Test
public void test(){
    System.out.println(this.handler("str", str -> (str + "123")));
}

//处理字符串
public String handler(String str, Function<String,String> fun){
    return fun.apply(str);
}

4. Predicate：断言型接口

@Test
public void test(){
    List<String> stringList = Arrays.asList("qwe", "123", "hello", "ranhaifeng", "asdasdsaewqewqe");
    List<String> list = filterStr(stringList, s -> (s.length() > 3));
    for (String s : list) {
        System.out.println(s);
    }
}

//将满足条件的字符串放入集合
public List<String> filterStr(List<String> list, Predicate<String> pre){
    List<String> stringList = new ArrayList<>();
    for (String s : list) {
        if (pre.test(s)){
            stringList.add(s);
        }
    }
    return stringList;
}