必须掌握的基础10个Lambda表达式

1、集合遍历

以前处理的方式是这样的：

java">//以前的方式
public static void old(){
    List<String> list = Arrays.asList("wuhan", "tianjin", "beijing", "shanghai");
    for (String city : list){
        System.out.println(city);
    }
}

现在使用Lambda表达式x是这样处理的：

java">//现在的方式
public static void now(){
    List<String> list = Arrays.asList("wuhan", "tianjin", "beijing", "shanghai");
    list.forEach(city -> System.out.println(city));
}

完整代码如下：

java">package cn.bobo.lambda;

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

/**
 * <p>集合遍历</p>
 *
 * @author 波波老师(微信 ： javabobo0513)
 */
public class Test01 {

    public static void main(String[] args) {
        System.out.println("以前的方式：");
        old();

        System.out.println("Lambda表达式的方式：");
        now();
    }

    //以前的方式
    public static void old(){
        List<String> list = Arrays.asList("wuhan", "tianjin", "beijing", "shanghai");
        for (String city : list){
            System.out.println(city);
        }
    }

    //现在的方式
    public static void now(){
        List<String> list = Arrays.asList("wuhan", "tianjin", "beijing", "shanghai");
        list.forEach(city -> System.out.println(city));
    }
}

运行结果如下：

以前的方式：
wuhan
tianjin
beijing
shanghai
Lambda表达式的方式：
wuhan
tianjin
beijing
shanghai

为了后面方便测试，我们新建【学生】实体类，代码如下：

java">package cn.bobo.dto;

import lombok.Data;

/**
 * <p>学生对象</p>
 *
 * @author 波波老师(微信 ： javabobo0513)
 */
@Data
public class Student {

    private Long id;
    private String userName;
    private Integer age;
    private String sex;

    public Student(Long id, String userName, Integer age, String sex) {
        this.id = id;
        this.userName = userName;
        this.age = age;
        this.sex = sex;
    }
}

2、排序

以前处理的方式是这样的：

java">//以前的方式
public static void old(){
    List<String> list = Arrays.asList("wuhan", "tianjin", "beijing", "shanghai");
    Collections.sort(list, new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            return o1.compareTo(o2);
        }
    });
    System.out.println(list);
}

现在使用Lambda表达式x是这样处理的：

java">//现在的方式
public static void now(){
    List<String> list = Arrays.asList("wuhan", "tianjin", "beijing", "shanghai");
    Collections.sort(list, (o1,o2)->o1.compareTo(o2));
    System.out.println(list);
}

完整代码如下：

java">package cn.bobo.lambda;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * <p>排序</p>
 *
 * @author 波波老师(微信 ： javabobo0513)
 */
public class Test02 {

    public static void main(String[] args) {
        System.out.println("以前的方式：");
        old();

        System.out.println("Lambda表达式的方式：");
        now();
    }

    //以前的方式
    public static void old(){
        List<String> list = Arrays.asList("wuhan", "tianjin", "beijing", "shanghai");
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
        System.out.println(list);
    }

    //现在的方式
    public static void now(){
        List<String> list = Arrays.asList("wuhan", "tianjin", "beijing", "shanghai");
        Collections.sort(list, (o1,o2)->o1.compareTo(o2));
        System.out.println(list);
    }
}

运行结果如下：

以前的方式：
[beijing, shanghai, tianjin, wuhan]
Lambda表达式的方式：
[beijing, shanghai, tianjin, wuhan]

对象进行排序，代码如下：

java">public static void nowObject(){
    List<Student> list = Arrays.asList(
        new Student(1L, "张三", 23, "男"),
        new Student(2L, "李四", 20, "女"),
        new Student(3L, "王五", 29, "男"),
        new Student(4L, "赵六", 24, "女")
    );
    //按照年龄升序排序
    list.sort(Comparator.comparing(Student::getAge));
    System.out.println(list);
}

运行结果：

[Student(id=2, userName=李四, age=20), Student(id=1, userName=张三, age=23), Student(id=4, userName=赵六, age=24), Student(id=3, userName=王五, age=29)]

3、过滤

需求：找出集合中以字幕【s】开头的所有元素

以前处理的方式是这样的：

java">//以前的方式
public static void old(){
    List<String> list = Arrays.asList("wuhan", "tianjin", "beijing", "shanghai");
    List list2 = new ArrayList<>();
    for (String s : list) {
        if (s.startsWith("s")) {
            list2.add(s);
        }
    }
    System.out.println(list2);
}

现在使用Lambda表达式x是这样处理的：

java">//现在的方式
public static void now(){
    List<String> list = Arrays.asList("wuhan", "tianjin", "beijing", "shanghai");
    List<String> list2 = list.stream().filter(s-> s.startsWith("s")).collect(Collectors.toList());
    System.out.println(list2);
}

完整代码如下：

java">package cn.bobo.lambda;

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

/**
 * <p>过滤</p>
 *
 * @author 波波老师(微信 ： javabobo0513)
 */
public class Test03 {

    public static void main(String[] args) {
        System.out.println("以前的方式：");
        old();

        System.out.println("Lambda表达式的方式：");
        now();
    }

    //以前的方式
    public static void old(){
        List<String> list = Arrays.asList("wuhan", "tianjin", "beijing", "shanghai");
        List list2 = new ArrayList<>();
        for (String s : list) {
            if (s.startsWith("s")) {
                list2.add(s);
            }
        }
        System.out.println(list2);
    }

    //现在的方式
    public static void now(){
        List<String> list = Arrays.asList("wuhan", "tianjin", "beijing", "shanghai");
        List<String> list2 = list.stream().filter(s-> s.startsWith("s")).collect(Collectors.toList());
        System.out.println(list2);
    }
}

运行结果如下：

以前的方式：
[shanghai]
Lambda表达式的方式：
[shanghai]

4、映射

需求：取出集合中每一个元素的长度

以前处理的方式是这样的：

java">//以前的方式
public static void old(){
    List<String> list = Arrays.asList("wuhan", "tianjin", "beijing", "shanghai");
    List<Integer> list2 = new ArrayList<>();
    for (String s : list) {
        list2.add(s.length());
    }
    System.out.println(list2);
}

现在使用Lambda表达式x是这样处理的：

java">//现在的方式
public static void now(){
    List<String> list = Arrays.asList("wuhan", "tianjin", "beijing", "shanghai");
    List list2 = list.stream().map(s -> s.length()).collect(Collectors.toList());
    System.out.println(list2);
}

完整代码如下：

java">package cn.bobo.lambda;

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

/**
 * <p>映射</p>
 *
 * @author 波波老师(微信 ： javabobo0513)
 */
public class Test04 {

    public static void main(String[] args) {
        System.out.println("以前的方式：");
        old();

        System.out.println("Lambda表达式的方式：");
        now();
    }

    //以前的方式
    public static void old(){
        List<String> list = Arrays.asList("wuhan", "tianjin", "beijing", "shanghai");
        List<Integer> list2 = new ArrayList<>();
        for (String s : list) {
            list2.add(s.length());
        }
        System.out.println(list2);
    }

    //现在的方式
    public static void now(){
        List<String> list = Arrays.asList("wuhan", "tianjin", "beijing", "shanghai");
        List list2 = list.stream().map(s -> s.length()).collect(Collectors.toList());
        System.out.println(list2);
    }
}

运行结果如下：

以前的方式：
[5, 7, 7, 8]
Lambda表达式的方式：
[5, 7, 7, 8]

5、规约

需求：求一个集合中的所有Integer类型值的和

以前处理的方式是这样的：

java">//以前的方式
public static void old(){
    List<Integer> list = Arrays.asList(10, 20, 30, 40, 50, 60);
    int sum = 0;
    for (Integer i : list) {
        sum += i;
    }
    System.out.println(sum);
}

现在使用Lambda表达式x是这样处理的：

java">//现在的方式
public static void now(){
    List<Integer> list = Arrays.asList(10, 20, 30, 40, 50, 60);
    int sum = list.stream().reduce(0, (a, b) -> a + b);
    System.out.println(sum);
}

完整代码如下：

java">package cn.bobo.lambda;

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

/**
 * <p>规约</p>
 *
 * @author 波波老师(微信 ： javabobo0513)
 */
public class Test05 {

    public static void main(String[] args) {
        System.out.println("以前的方式：");
        old();

        System.out.println("Lambda表达式的方式：");
        now();
    }

    //以前的方式
    public static void old(){
        List<Integer> list = Arrays.asList(10, 20, 30, 40, 50, 60);
        int sum = 0;
        for (Integer i : list) {
            sum += i;
        }
        System.out.println(sum);
    }

    //现在的方式
    public static void now(){
        List<Integer> list = Arrays.asList(10, 20, 30, 40, 50, 60);
        int sum = list.stream().reduce(0, (a, b) -> a + b);
        System.out.println(sum);
    }
}

运行结果如下：

以前的方式：
210
Lambda表达式的方式：
210

6、分组

需求：按照元素长度进行分组，每个长度一个组

以前处理的方式是这样的：

java">//以前的方式
public static void old(){
    List<String> list = Arrays.asList("wuhan", "tianjin", "beijing", "shanghai");
    Map<Integer, List<String>> groups = new HashMap<>();
    for(String s: list){
        int length = s.length();
        if(!groups.containsKey(length)){
            groups.put(length, new ArrayList<>());
        }
        groups.get(length).add(s);
    }
    System.out.println(groups);
}

现在使用Lambda表达式x是这样处理的：

java">//现在的方式
public static void now(){
    List<String> list = Arrays.asList("wuhan", "tianjin", "beijing", "shanghai");
    Map<Integer, List<String>> groups = list.stream().collect(Collectors.groupingBy(String:: length));
    System.out.println(groups);
}

完整代码如下：

java">package cn.bobo.lambda;

import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>分组</p>
 *
 * @author 波波老师(微信 ： javabobo0513)
 */
public class Test06 {

    public static void main(String[] args) {
        System.out.println("以前的方式：");
        old();

        System.out.println("Lambda表达式的方式：");
        now();
    }

    //以前的方式
    public static void old(){
        List<String> list = Arrays.asList("wuhan", "tianjin", "beijing", "shanghai");
        Map<Integer, List<String>> groups = new HashMap<>();
        for(String s: list){
            int length = s.length();
            if(!groups.containsKey(length)){
                groups.put(length, new ArrayList<>());
            }
            groups.get(length).add(s);
        }
        System.out.println(groups);
    }

    //现在的方式
    public static void now(){
        List<String> list = Arrays.asList("wuhan", "tianjin", "beijing", "shanghai");
        Map<Integer, List<String>> groups = list.stream().collect(Collectors.groupingBy(String:: length));
        System.out.println(groups);
    }
}

运行结果如下：

以前的方式：
{5=[wuhan], 7=[tianjin, beijing], 8=[shanghai]}
Lambda表达式的方式：
{5=[wuhan], 7=[tianjin, beijing], 8=[shanghai]}

对象进行分组，需求：按照性别进行分组，代码如下：

java">public static void nowObject(){
    List<Student> list = Arrays.asList(
        new Student(1L, "张三", 23, "男"),
        new Student(2L, "李四", 20, "女"),
        new Student(3L, "王五", 29, "男"),
        new Student(4L, "赵六", 24, "女"),
        new Student(5L, "李丽", 21, "女")
    );
    //根据性别分组统计人数
    Map<String, Long> map = list.stream().collect(Collectors.groupingBy(Student::getSex, Collectors.counting()));
    //打印分组后的信息
    map.forEach((k, v) -> System.out.println(k + " -> 人数=" + v));
}

运行结果：

女 -> 人数=3
男 -> 人数=2

7、函数式接口的实现

以前处理的方式是这样的：

java">//以前的方式
public static void old(){
    InterfaceDemo interfaceDemo = new InterfaceDemo(){
        @Override
        public void seyHello(String name) {
            System.out.println("hello:" + name);
        }
    };
    interfaceDemo.seyHello("tom");
}

现在使用Lambda表达式x是这样处理的：

java">//现在的方式
public static void now(){
    InterfaceDemo interfaceDemo = (s) -> System.out.println("hello:" + s);
    interfaceDemo.seyHello("tom");
}

完整代码如下：

java">package cn.bobo.lambda;

/**
 * <p>函数式接口的实现</p>
 *
 * @author 波波老师(微信 ： javabobo0513)
 */
public class Test07 {

    public static void main(String[] args) {
        System.out.println("以前的方式：");
        old();

        System.out.println("Lambda表达式的方式：");
        now();
    }

    //以前的方式
    public static void old(){
        InterfaceDemo interfaceDemo = new InterfaceDemo(){
            @Override
            public void seyHello(String name) {
                System.out.println("hello:" + name);
            }
        };
        interfaceDemo.seyHello("tom");
    }

    //现在的方式
    public static void now(){
        InterfaceDemo interfaceDemo = (s) -> System.out.println("hello:" + s);
        interfaceDemo.seyHello("tom");
    }
}

interface InterfaceDemo{
    void seyHello(String name);
}

运行结果如下：

以前的方式：
hello:tom
Lambda表达式的方式：
hello:tom

8、线程的创建

以前处理的方式是这样的：

java">//以前的方式
public static void old(){
    Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("我是新线程：" + Thread.currentThread().getName());
        }
    });
    thread.start();
}

现在使用Lambda表达式x是这样处理的：

java">//现在的方式
public static void now(){
    Thread thread = new Thread(() -> System.out.println("我是新线程：" + Thread.currentThread().getName()));
    thread.start();
}

完整代码如下：

java">package cn.bobo.lambda;

/**
 * <p>创建线程</p>
 *
 * @author 波波老师(微信 ： javabobo0513)
 */
public class Test08 {

    public static void main(String[] args) {
        System.out.println("以前的方式：");
        old();

        System.out.println("Lambda表达式的方式：");
        now();
    }

    //以前的方式
    public static void old(){
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("我是新线程：" + Thread.currentThread().getName());
            }
        });
        thread.start();
    }

    //现在的方式
    public static void now(){
        Thread thread = new Thread(() -> System.out.println("我是新线程：" + Thread.currentThread().getName()));
        thread.start();
    }
}

运行结果如下：

以前的方式：
Lambda表达式的方式：
我是新线程：Thread-0
我是新线程：Thread-1

9、Optional操作

以前处理的方式是这样的：

java">//以前的方式
public static void old(){
    String str = "我要学习Lambda表达式";
    if(str != null){
        System.out.println(str.toUpperCase());
    }
}

现在使用Lambda表达式x是这样处理的：

java">//现在的方式
public static void now(){
    String str = "我要学习Lambda表达式";
    Optional.of(str).map(String :: toUpperCase).ifPresent(System.out::println);
}

完整代码如下：

java">package cn.bobo.lambda;

import java.util.Optional;

/**
 * <p>Optional操作</p>
 *
 * @author 波波老师(微信 ： javabobo0513)
 */
public class Test09 {

    public static void main(String[] args) {
        System.out.println("以前的方式：");
        old();

        System.out.println("Lambda表达式的方式：");
        now();
    }

    //以前的方式
    public static void old(){
        String str = "我要学习Lambda表达式";
        if(str != null){
            System.out.println(str.toUpperCase());
        }
    }

    //现在的方式
    public static void now(){
        String str = "我要学习Lambda表达式";
        Optional.of(str).map(String :: toUpperCase).ifPresent(System.out::println);
    }
}

运行结果如下：

以前的方式：
我要学习LAMBDA表达式
Lambda表达式的方式：
我要学习LAMBDA表达式

10、Stream的流水线操作

需求：找到集合中以字母s开头的元素，并转成大写收集起来

以前处理的方式是这样的：

java">//以前的方式
public static void old(){
    List<String> list = Arrays.asList("wuhan", "tianjin", "beijing", "shanghai");
    List<String> listTemp = new ArrayList<>();
    for (String city : list) {
        if (city.startsWith("s")) {
            listTemp.add(city.toUpperCase());
        }
    }
    Collections.sort(listTemp);
    System.out.println(listTemp);
}

现在使用Lambda表达式x是这样处理的：

java">//现在的方式
public static void now(){
    List<String> list = Arrays.asList("wuhan", "tianjin", "beijing", "shanghai");
    List listTemp = list.stream().filter(city -> city.startsWith("s"))
        .map(String::toUpperCase)
        .sorted()
        .collect(Collectors.toList());
    System.out.println(listTemp);
}

完整代码如下：

java">package cn.bobo.lambda;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

/**
 * <p>Stream的流水线操作</p>
 *
 * @author 波波老师(微信 ： javabobo0513)
 */
public class Test10 {

    public static void main(String[] args) {
        System.out.println("以前的方式：");
        old();

        System.out.println("Lambda表达式的方式：");
        now();
    }

    //以前的方式
    public static void old(){
        List<String> list = Arrays.asList("wuhan", "tianjin", "beijing", "shanghai");
        List<String> listTemp = new ArrayList<>();
        for (String city : list) {
            if (city.startsWith("s")) {
                listTemp.add(city.toUpperCase());
            }
        }
        Collections.sort(listTemp);
        System.out.println(listTemp);
    }

    //现在的方式
    public static void now(){
        List<String> list = Arrays.asList("wuhan", "tianjin", "beijing", "shanghai");
        List listTemp = list.stream().filter(city -> city.startsWith("s"))
                .map(String::toUpperCase)
                .sorted()
                .collect(Collectors.toList());
        System.out.println(listTemp);
    }
}

运行结果如下：

以前的方式：
[SHANGHAI]
Lambda表达式的方式：
[SHANGHAI]

总结

经过上面案例的学习，相信大家感受到了Lambda表达式的简洁与强大，但是也有同学会认为，虽然简洁，但是可读性变差了，复杂的Lambda表达式语句在实际工作中也不方便Debug调试。这就看个人喜好了，还有就是公司的代码风格和规范了，大家先掌握这些语法后，以后进入公司后入乡随俗就可以了