lambda表达式详解及实际运用

简介

• Lambda 表达式，也可称为闭包（闭包就是能够将一个方法作为一个变量去存储，这个方法有能力去访问所在类的自由变量），它是推动 Java 8 发布的最重要新特性。
• Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。
• 使用 Lambda 表达式可以使代码变的更加简洁紧凑。
• lambda表达式并不可以对所有的接口进行简单实现，只有函数式接口可以使用lambda表达式
  什么是函数式接口？

语法

（）参数列表，{}方法体，-> lambda运算符（goes to）
lambda 表达式的语法格式如下：
(参数列表) -> 表达式
或
(参数列表) ->{ 语句; }

示例

先声明一个函数式接口

package com.cp.test;

/*函数式接口*/
@FunctionalInterface
public interface Add {

    int addNum(int a, int b);

    /*java1.8开始可以写default修饰的方法*/
    default void add(int a, int b){
        System.out.println(a+b);
    }
}

有3种方法可以实现接口中的方法

package com.cp.test;

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;

        //第一种方法：写一个实现类实现接口中的方法，然后创建实现类对象调用该方法

        //第二种方法：匿名内部类实现的方法
        Add x = new Add() {
            @Override
            public int addNum(int a, int b) {
                return a + b;
            }
        };
        System.out.println("原始实现："+x.addNum(a, b));

        //第三种方法：使用lambda表达式
        Add y = (int c, int d) -> {
            return c + d;
        };
        System.out.println("lambda简化前"+y.addNum(a,b));

        /*
        * 语法简化
        * 1.可以不写参数类型（要么都写类型，要么都不写）
        * 2.如果只有一个参数，可以不写小括号
        * 3.如果只有一条需要执行的语句可以不写大括号
        * 4.如果只有一条语句,并且是return，可以省略return和大括号
        * */

        /*简化后*/
        Add s = (m, n) -> m + n;
        System.out.println("lambda简化后"+s.addNum(a, b));
    }
}

在集合中的应用

对list和set集合进行排序（集合中存放的是对象）

先创建一个对象重写toString方法

package com.cp.lambda;

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

下面分别使用list和set集合存储6个不同的对象，然后按年龄排序输出

package com.cp.lambda;

import java.util.*;

public class ConnectionSort {

    public static void main(String[] args) {

        //创建对象
        Person p1 = new Person("t1",15);
        Person p2 = new Person("t2",19);
        Person p3 = new Person("t3",5);
        Person p4 = new Person("t4",11);
        Person p5 = new Person("t5",25);
        Person p6 = new Person("t6",15);

        //集合中添加对象
        List<Person> list = new ArrayList<>();
        list.add(p1);
        list.add(p2);
        list.add(p3);
        list.add(p4);
        list.add(p5);
        list.add(p6);

        /*使用Collections工具类排序法*/
        /*Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o2.getAge() - o1.getAge();
            }
        });*/


        /*升序*/
        list.sort(Comparator.comparingInt(Person::getAge));

        /*使用lambda表达式降序输出*/
        list.sort((q1,q2) -> q2.getAge()-q1.getAge());

        System.out.println(list);

        System.out.println("=====================================================");

        /*
        *@chenPing
        * set排序
        * 注意set集合有去重功能，所以用lambda表达式时需要注意，不能return0
        * */
        TreeSet<Person> set = new TreeSet<>((o1,o2) -> {
            int age = o2.getAge() - o1.getAge();
            if (age >= 0){
                return 1;
            } else {
                return -1;
            }
        });
        set.add(p1);
        set.add(p2);
        set.add(p3);
        set.add(p4);
        set.add(p5);
        set.add(p6);
        System.out.println(set);
    }
}