【Lambda表达式十种常用方式】

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

public class Demo01 {

    public static void main(String[] args) {
        // 1. 进行集合遍历
        List<String> list1 = Arrays.asList("red", "yellow", "black");
        for (String s : list1) {
            System.out.println(s);
        }
        list1.forEach(item -> System.out.println(item));
        list1.forEach(System.out::println);

        // 2. 进行排序
        List<String> list2 = Arrays.asList("red", "yellow", "black");
        Collections.sort(list2, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
        Collections.sort(list2, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
        Collections.sort(list2, ((o1, o2) -> o1.compareTo(o2)));

        // 3. 进行过滤
        List<String> list3 = Arrays.asList("red", "yellow", "black");
        List<String> result1 = new ArrayList<>();
        for (String item : list3) {
            if (item.startsWith("r")) {
                result1.add(item);
            }
        }
        List<String> result2 = list3.stream()
                .filter(item -> item.startsWith("r"))
                .collect(Collectors.toList());

        // 4. 进行映射
        List<String> list4 = Arrays.asList("red", "yellow", "black");
        List<Integer> lenColl1 = new ArrayList<>();
        for (String item : list4) {
            lenColl1.add(item.length());
        }
        List<Integer> lenColl2 = list4.stream()
                .map(item -> item.length())
                .collect(Collectors.toList());

        // 5. 进行规约
        List<Integer> list5 = Arrays.asList(1, 2, 3, 4, 5);
        int sum = 0;
        for (Integer i : list5) {
            sum += i;
        }

        Integer reduce = list5.stream().reduce(0, (a, b) -> a + b);

        // 6. 进行分组
        List<String> list6 = Arrays.asList("red", "yellow", "black");
        Map<Integer, List<String>> group1 = new HashMap<>();
        for (String item : list6) {
            int length = item.length();
            if (!group1.containsKey(length)) {
                group1.put(length, new ArrayList<>());
            }else {
                group1.get(length).add(item);
            }
        }
        Map<Integer, List<String>> group2 = list6.stream()
                .collect(Collectors.groupingBy(item -> item.length()));

        // 7. 进行函数式接口实现
        MyInterface myInterface = new MyInterface() {
            @Override
            public void doSomeThing(String input) {
                System.out.println(input);
            }
        };

        MyInterface myInterface1 = input -> System.out.println(input);

        // 8. 进行线程创建

        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread is running");
            }
        });
        thread.start();

        new Thread(() -> System.out.println("Thread is running")).start();

        //9. 进行Optional的操作
        String str = "Hello World";
        if (str != null) {
            System.out.println(str.toUpperCase());
        }

        Optional<String> str1 = Optional.ofNullable("Hello World");
        str1.map(String::toUpperCase).ifPresent(System.out::println);

        //10. 进行Stream的流水线操作
        List<String> list10 = Arrays.asList("red", "yellow", "black");
        List<String> filterList = new ArrayList<>();
        for (String s : list10) {
            if (s.startsWith("a")) {
                filterList.add(s.toUpperCase());
            }
        }
        Collections.sort(filterList);

        List<String> result10 = list10.stream().filter(item -> item.startsWith("a"))
                .map(String::toUpperCase)
                .sorted()
                .collect(Collectors.toList());
    }


}

interface MyInterface {
    void doSomeThing(String input);
}