【学习笔记】Lambda表达式常见用法

Lambda表达式

1.集合遍历

public class LambdaTest {
    public static void main(String[] args) {
        List<String> list1 = Arrays.asList("aaa","bbb","ccc");

        // 常规写法(for i 和 for each)
        for (int i = 0; i < list1.size(); i++) {
            System.out.println(list1.get(i));
        }
        for (String l : list1) {
            System.out.println(l);
        }

        // Lambda表达式写法
        list1.forEach(s -> System.out.println(s));
        list1.forEach(System.out::println); // 简写
    }
}

2.集合排序

public class LambdaTest {
    public static void main(String[] args) {
        List<String> list1 = Arrays.asList("aaa","bbb","ccc");

        // 常规写法
        Collections.sort(list1, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });

        // Lambda表达式写法
        Collections.sort(list1, (o1, o2) -> o1.compareTo(o2));
    }
}

3.过滤

public class LambdaTest {
    public static void main(String[] args) {
        List<String> list1 = Arrays.asList("aaa","bbb","ccc");

        // 常规写法
        List<String> list2 = new ArrayList<>();
        for (String s : list1) {
            if (s.startsWith("a")){
                list2.add(s);
            }
        }

        // Lambda表达式写法
        List<String> list3 = list1.stream().filter(s -> s.startsWith("a")).collect(Collectors.toList()); // collect(Collectors.toList())是转化为集合
    }
}

4.映射

public class LambdaTest {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple","banana","peach");
        // 常规用法
        List<Integer> list2 = new ArrayList<>();
        for (String s : list) {
            list2.add(s.length());
        }

        // Lambda表达式
        List<Integer> list3 = list.stream().map(s -> s.length()).collect(Collectors.toList());
    }
}

5.求和

public class LambdaTest {
    public static void main(String[] args) {
        List<Integer> list1 = Arrays.asList(2, 3, 5);

        // 常规写法
        int sum1 = 0;
        for (Integer s : list1) {
            sum1 += s;
        }

        // Lambda表达式写法
        // reduce(初始值，(a, b) -> a + b)      a-sum , b-s
        int sum2 = list1.stream().reduce(0, (a, b) -> a + b);
    }
}

6.分组

public class LambdaTest {
    public static void main(String[] args) {
        List<String> list1 = Arrays.asList("aaa", "bbb", "ccc", "ddddd");

        // 常规写法
        Map<Integer,List<String>> map1 = new HashMap<>();
        for (String i: list1) {
            int length = i.length();
            if (!map1.containsKey(length)){
                map1.put(length, new ArrayList<>());
            }
            map1.get(length).add(i);
        }

        // Lambda表达式写法
        Map<Integer,List<String>> map2 = list1.stream().collect(Collectors.groupingBy(String::length));
    }
}

7.实现接口

public interface LambdaInterface {
    void doSomething(String s);
}

public class LambdaTest {
    public static void main(String[] args) {
        // 常规用法
        LambdaInterface lambdaInterface = new LambdaInterface() {
            @Override
            public void doSomething(String s) {
                System.out.println(s);
            }
        };
        lambdaInterface.doSomething("hello world");

        // Lambda表达式
        LambdaInterface lambdaInterface12 = (s) -> System.out.println(s);
        lambdaInterface12.doSomething("hello world");
    }
}

8.创建线程

public class LambdaTest {
    public static void main(String[] args) {
        // 常规用法
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("thread 01");
            }
        });
        thread1.start();

        // Lambda表达式
        Thread thread2 = new Thread(() -> System.out.println("thread 02"));
        thread2.start();
    }
}

9.Optional判空操作（可以避免空指针）

public class LambdaTest {
    public static void main(String[] args) {
        String str = "string";
        // 常规用法
        if (str != null){
            System.out.println(str.toUpperCase());
        }

        // Lambda表达式
        Optional.ofNullable(str).map(String::toUpperCase).ifPresent(System.out::println);
    }
}

10.流水线操作

public class LambdaTest {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple","banana","peach");
        // 常规用法
        List<String> list2 = new ArrayList<>();
        for (String s : list) {
            if (s.startsWith("a")){
                list2.add(s.toUpperCase());
            }
        }
        Collections.sort(list2);

        // Lambda表达式
        List<String> list3 = list.stream().filter(s -> s.startsWith("a")) // 过滤
                .map(String::toUpperCase) // 格式转换
                .sorted() // 排序
                .collect(Collectors.toList()); // 转为集合
    }
}