new Thread(new Runnable() {
    @Override
    public void run() {
        // ...
    }
}).start();

new Thread(() -> {
    // ...
}).start();

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

interface MyFunc {
  String show(Integer i);
}

interface MyFunc1 {
    void func();
}

// 空實(shí)現(xiàn)
MyFunc1 f11 = () -> { };
// 只有一行語句
MyFunc1 f12 = () -> {
    System.out.println(1);
    System.out.println(2);
};
// 只有一行語句
MyFunc1 f13 = () -> {
    System.out.println(1);
};
// 只有一行語句可以省略 { }
MyFunc1 f14 = () -> System.out.println(1);

interface MyFunc2 {
    void func(String str);
}

// 函數(shù)體空實(shí)現(xiàn)
MyFunc2 f21 = (str) -> { };
// 單個(gè)參數(shù)可以省略 () 多個(gè)不可以省略
MyFunc2 f22 = str -> System.out.println(str.length());

interface MyFunc3 {
    int func();
}

// 返回值
MyFunc3 f31 = () -> {return 1;};
// 如果只有一個(gè)return 語句時(shí)可以直接寫return 后面的表達(dá)式語句
MyFunc3 f32 = () -> 1;

interface MyFunc4 {
    int func(String str);
}

// 這里單個(gè)參數(shù)簡(jiǎn)寫了{(lán)}
MyFunc4 f41 = str -> {
    return str.length();
};
// 這里又簡(jiǎn)寫了return
MyFunc4 f42 = str -> str.length();
// 這里直接使用了方法引用進(jìn)行了簡(jiǎn)寫 - 在文章后續(xù)章節(jié)有介紹到
MyFunc4 f43 = String::length;

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}

// 將字符串轉(zhuǎn)為數(shù)字，再平方
Function<String, Integer> strConvertToIntAndSquareFun = (str) -> {
    Integer value = Integer.valueOf(str);
    return value * value;
};
Integer result = strConvertToIntAndSquareFun.apply("4");
System.out.println(result); // 16

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

// 供給接口，調(diào)用一次返回一個(gè) ”tom“ 字符串
Supplier<String> tomFun = () -> "tom";
String tom = tomFun.get();
System.out.println(tom); // tom

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}	

// 重復(fù)打印
Consumer<Integer> printA = (n)->{
    for (int i = 0; i < n; i++) {
        System.out.print("A");
    }
    System.out.println();
};
printA.accept(5); // AAAAA

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);	
}

// 判斷是否為`A`字母開頭且`Z`字母結(jié)尾
Predicate<String> strAStartAndZEnd = (str) -> {
    return str.startsWith("A") && str.endsWith("Z");
};
System.out.println(strAStartAndZEnd.test("AaaaZ")); // true 
System.out.println(strAStartAndZEnd.test("Aaaaa")); // false
System.out.println(strAStartAndZEnd.test("aaaaZ")); // false
System.out.println(strAStartAndZEnd.test("aaaaa")); // false

MyFunc4 f43 = String::length; // 這個(gè)地方就用到了方法引用

public int length() {
    return value.length;
}

interface MyFunc4 {
    int func(String str);
}

public class Student {
    public void show() {
        // ...
    }
    public void print(int a) {
        // ...
    }
}

public void show(String this);
public void print(String this, int a);

String::length;
public int length() {
    return value.length;
}

// 相當(dāng)于
public int length(String str) {
    return str.length();
}
// 這樣看length就和函數(shù)式接口MyFunc4的傳參和返回值就相同了

IntFunction<int[]> arrFun = int[]::new;
int[] arr = arrFun.apply(10); // 生成一個(gè)長(zhǎng)度為10的數(shù)組

private Optional(T value) {
    // 傳 null 會(huì)報(bào)空指針異常
    this.value = Objects.requireNonNull(value);
}

public static<T> Optional<T> empty() {
    @SuppressWarnings("unchecked")
    Optional<T> t = (Optional<T>) EMPTY;
    return t;
}

public static <T> Optional<T> of(T value) {
    return new Optional<>(value);
}

public static <T> Optional<T> ofNullable(T value) {
    return value == null ? empty() : of(value);
}

Optional<Integer> opt = Optional.of(123);
opt.ifPresent((x) -> {
	System.out.println(opt);
});
// out: 123

public T orElse(T other) {
    return value != null ? value : other;
}

public T orElseGet(Supplier<? extends T> other) {
    return value != null ? value : other.get();
}

// 當(dāng)param為null時(shí) 返回空集合
Optional.ofNullable(param).orElse(Collections.emptyList());
Optional.ofNullable(param).orElseGet(() -> Collections.emptyList());

// 方式1，數(shù)組轉(zhuǎn)Stream
Arrays.stream(arr);
// 方式2，數(shù)組轉(zhuǎn)Stream，看源碼of就是方法1的包裝
Stream.of(arr);
// 方式3，調(diào)用Collection接口的stream()方法
List<String> list = new ArrayList<>();
list.stream();

// 打印流中的每一個(gè)元素
Stream.of("jerry", "lisa", "moli", "tom", "Demi").forEach(str -> {
    System.out.println(str);
});

Stream.of("jerry", "lisa", "moli", "tom", "Demi")
    .forEach(System.out::println);

Stream.of("jerry", "lisa", "moli", "tom", "Demi")
    // 過濾
    .filter(str -> str.length() > 3)
    .forEach(System.out::println);
/*
輸出：
jerry
lisa
moli
Demi
*/

Stream.of("jerry", "lisa", "moli", "tom", "Demi")
    .limit(2)
    .forEach(System.out::println);
/*
輸出：
jerry
lisa
*/

// 丟棄前2個(gè)元素
Stream.of("jerry", "lisa", "moli", "tom", "Demi")
    .skip(2)
    .forEach(System.out::println);
/*
輸出：
moli
tom
Demi
*/

// 為每一個(gè)元素加上 一個(gè)前綴 "name: "
Stream.of("jerry", "lisa", "moli", "tom", "Demi")
    .map(str -> "name: " + str)
    .forEach(System.out::println);
/*
輸出：
name: jerry
name: lisa
name: moli
name: tom
name: Demi
*/

Stream.of("one", "two", "three", "four")
    // 第1次查看
    .peek(e -> System.out.println("第1次 value: " + e))
    // 過濾掉長(zhǎng)度小于3的字符串
    .filter(e -> e.length() > 3)
    // 第2次查看
    .peek(e -> System.out.println("第2次 value: " + e))
    // 將流中剩下的字符串轉(zhuǎn)為大寫
    .map(String::toUpperCase)
    // 第3次查看
    .peek(e -> System.out.println("第3次 value: " + e))
    // 收集為L(zhǎng)ist
    .collect(Collectors.toList());

/*
輸出：
第1次 value: one
第1次 value: two
第1次 value: three
第2次 value: three
第3次 value: THREE
第1次 value: four
第2次 value: four
第3次 value: FOUR
*/

public class User {
    public String name;

    public User(String name) {
        this.name = name;
    }

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

Stream.of(new User("tom"), new User("jerry"))
    .peek(e -> {
        e.name = "US:" + e.name;
    })
    .forEach(System.out::println);
/*
輸出：
User{name='US:tom'}
User{name='US:jerry'}
*/

// 排序數(shù)據(jù)
Stream.of(4, 2, 1, 3)
    // 默認(rèn)是升序
    .sorted()
    .forEach(System.out::println);
/*
輸出：
1
2
3
4
*/

// 排序數(shù)據(jù)
Stream.of(4, 2, 1, 3)
    // 逆序
    .sorted(Comparator.reverseOrder())
    .forEach(System.out::println
/*
輸出：
4
3
2
1
*/

public class User {
    public String name;

    public User(String name) {
        this.name = name;
    }

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

// 名稱長(zhǎng)的排前面
Stream.of(new User("tom"), new User("jerry"))
    .sorted((e1, e2) -> {
        return e2.name.length() - e1.name.length();
    })
    .forEach(System.out::println);
/*
輸出：
User{name='US:jerry'}
User{name='US:tom'}
*/	

Stream.of(2, 2, 4, 4, 3, 3, 100)
    .distinct()
    .forEach(System.out::println);
/*
輸出：
2
4
3
100
*/

List<Integer[]> arrList = new ArrayList<>();
arrList.add(arr1);
arrList.add(arr2);
// 未使用
arrList.stream()
    .forEach(e -> {
        System.out.println(Arrays.toString(e));
    });

/*
輸出：
[1, 2]
[3, 4]
*/	

// 平鋪后
arrList.stream()
    .flatMap(arr -> Stream.of(arr))
    .forEach(e -> {
        System.out.println(e);
    });

/*
輸出：
1
2
3
4
*/

// 最大值
Optional<Integer> maxOpt = Stream.of(2, 4, 3, 100)
    .max(Comparator.comparing(e -> e));
System.out.println(maxOpt.get()); // 100

// 最小值
Optional<Integer> minOpt = Stream.of(2, 4, 3, 100)
    .min(Comparator.comparing(Function.identity()));
System.out.println(minOpt.get()); // 2

// 數(shù)量
long count = Stream.of("one", "two", "three", "four")
    .count();
System.out.println(count); // 4

static <T> Function<T, T> identity() {
    return t -> t;
}

Optional<String> anyOpt = Stream.of("one", "two", "three", "four")
    .findAny();
System.out.println(anyOpt.orElse(""));
/*
輸出：
one
*/	

Optional<String> firstOpt = Stream.of("one", "two", "three", "four")
    .findFirst();

System.out.println(firstOpt.orElse(""));
/*
輸出：
one
*/	

// 是否全部為 one 字符串
boolean allIsOne = Stream.of("one", "two", "three", "four")
    .allMatch(str -> Objects.equals("one", str));
System.out.println(allIsOne); // false

allIsOne = Stream.of("one", "one", "one", "one")
    .allMatch(str -> Objects.equals("one", str));
System.out.println(allIsOne); // true

// 是否包含 one 字符串
boolean hasOne = Stream.of("one", "two", "three", "four")
    .anyMatch(str -> Objects.equals("one", str));
System.out.println(hasOne); // true

hasOne = Stream.of("two", "three", "four")
    .anyMatch(str -> Objects.equals("one", str));
System.out.println(hasOne); // false

List<String> list = Stream.of("one", "two", "three", "four")
    .collect(Collectors.toList());
System.out.println(list);
/*
輸出：
[one, two, three, four]
*/	

Set<String> set = Stream.of("one", "one", "two", "three", "four")
    .collect(Collectors.toSet());
System.out.println(set);
/*
輸出：
[four, one, two, three]
*/	

String str1 = Stream.of("one", "two", "three", "four")
    .collect(Collectors.joining());
System.out.println(str1); // onetwothreefour
String str2 = Stream.of("one", "two", "three", "four")
    .collect(Collectors.joining(", "));
System.out.println(str2); // one, two, three, four

// 使用Lombok插件
@Data
@AllArgsConstructor
public class User {
    public Integer id;
    public String name;
}

Map<Integer, User> map = Stream.of(new User(1, "tom"), new User(2, "jerry"))
    .collect(Collectors.toMap(User::getId, Function.identity(), (k1, k2) -> k1));
System.out.println(map);
/*
輸出：
{
    1=User(id=1, name=tom), 
    2=User(id=2, name=jerry)
}
*/	

public static <T, K, U>
    Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper,
                                    Function<? super T, ? extends U> valueMapper,
                                    BinaryOperator<U> mergeFunction) {
    return toMap(keyMapper, valueMapper, mergeFunction, HashMap::new);
}
/*
keyMapper：Key 的映射函數(shù)
valueMapper：Value 的映射函數(shù)
mergeFunction：當(dāng) Key 沖突時(shí)，調(diào)用的合并方法
*/

@Data
@AllArgsConstructor
class User {
    public Integer id;
    public String name;
}
Map<String, List<User>> map = Stream.of(
    new User(1, "tom"), new User(2, "jerry"),
    new User(3, "moli"), new User(4, "lisa")
).collect(Collectors.groupingBy(u -> {
    if (u.id % 2 == 0) {
        return "奇";
    }
    return "偶";
}));
System.out.println(map);
/*
輸出：
{
    偶=[User(id=1, name=tom), User(id=3, name=moli)], 
    奇=[User(id=2, name=jerry), User(id=4, name=lisa)]
}
*/	

List<Student> studentList = new ArrayList<>();
studentList.add(new Student(1, "tom",    19, "男", "軟工"));
studentList.add(new Student(2, "lisa",   15, "女", "軟工"));
studentList.add(new Student(3, "Ada",    16, "女", "軟工"));
studentList.add(new Student(4, "Dora",   14, "女", "計(jì)科"));
studentList.add(new Student(5, "Bob",    20, "男", "軟工"));
studentList.add(new Student(6, "Farrah", 15, "女", "計(jì)科"));
studentList.add(new Student(7, "Helen",  13, "女", "軟工"));
studentList.add(new Student(8, "jerry",  12, "男", "計(jì)科"));
studentList.add(new Student(9, "Adam",   20, "男", "計(jì)科"));

/**
* 分頁(yè)方法
*
* @param list     要分頁(yè)的數(shù)據(jù)
* @param pageNo   當(dāng)前頁(yè)
* @param pageSize 頁(yè)大小
*/
public static <T> List<T> page(Collection<T> list, long pageNo, long pageSize) {
    if (Objects.isNull(list) || list.isEmpty()) {
        return Collections.emptyList();
    }
    return list.stream()
        .skip((pageNo - 1) * pageSize)
        .limit(pageSize)
        .collect(Collectors.toList());
}

List<Student> pageData = page(studentList, 1, 3);
System.out.println(pageData);
/*
輸出：
[
  Student(id=1, name=tom, age=19, sex=男, className=軟工), 
  Student(id=2, name=lisa, age=15, sex=女, className=軟工), 
  Student(id=3, name=Ada, age=16, sex=女, className=軟工)
]
*/

List<Integer> idList = studentList.stream()
    .filter(e -> Objects.equals(e.getClassName(), "軟工"))
    .map(Student::getId)
    .collect(Collectors.toList());
System.out.println(idList);
/*
輸出：
[1, 2, 3, 5, 7]
*/

Map<String, List<String>> map = studentList.stream()
        .collect(Collectors.groupingBy(
                Student::getClassName,
                Collectors.mapping(Student::getName, Collectors.toList())
        ));
System.out.println(map);
/*
輸出：
{
  計(jì)科=[Dora, Farrah, jerry, Adam], 
  軟工=[tom, lisa, Ada, Bob, Helen]
}
*/

Map<String, Long> map = studentList.stream()
    .collect(Collectors.groupingBy(
        Student::getClassName,
        Collectors.mapping(Function.identity(), Collectors.counting())
    ));
System.out.println(map);
/*
輸出：
{
  計(jì)科=4, 
  軟工=5
}
*/

List<String> allFemaleNameList = studentList.stream()
    .filter(stu -> Objects.equals("女", stu.getSex()))
    .map(Student::getName)
    .collect(Collectors.toList());
System.out.println(allFemaleNameList);
/*
輸出：
[lisa, Ada, Dora, Farrah, Helen]
*/

// 年齡升序排序
List<Student> stuList1 = studentList.stream()
    // 升序
    .sorted(Comparator.comparingInt(Student::getAge))
    .collect(Collectors.toList());
System.out.println(stuList1);
/*
輸出：
[
Student(id=8, name=jerry, age=12, sex=男, className=計(jì)科), 
Student(id=7, name=Helen, age=13, sex=女, className=軟工), 
Student(id=4, name=Dora, age=14, sex=女, className=計(jì)科), 
Student(id=2, name=lisa, age=15, sex=女, className=軟工), 
Student(id=6, name=Farrah, age=15, sex=女, className=計(jì)科), 
Student(id=3, name=Ada, age=16, sex=女, className=軟工), 
Student(id=1, name=tom, age=19, sex=男, className=軟工), 
Student(id=5, name=Bob, age=20, sex=男, className=軟工), 
Student(id=9, name=Adam, age=20, sex=男, className=計(jì)科)
]
*/

// 年齡降序排序
List<Student> stuList2 = studentList.stream()
    // 降序
    .sorted(Comparator.comparingInt(Student::getAge).reversed())
    .collect(Collectors.toList());
System.out.println(stuList2);
/*
輸出：
[
Student(id=5, name=Bob, age=20, sex=男, className=軟工), 
Student(id=9, name=Adam, age=20, sex=男, className=計(jì)科), 
Student(id=1, name=tom, age=19, sex=男, className=軟工), 
Student(id=3, name=Ada, age=16, sex=女, className=軟工), 
Student(id=2, name=lisa, age=15, sex=女, className=軟工), 
Student(id=6, name=Farrah, age=15, sex=女, className=計(jì)科), 
Student(id=4, name=Dora, age=14, sex=女, className=計(jì)科), 
Student(id=7, name=Helen, age=13, sex=女, className=軟工), 
Student(id=8, name=jerry, age=12, sex=男, className=計(jì)科)
]
*/

Map<String, List<Student>> map = studentList.stream()
        .collect(
                Collectors.groupingBy(
                        Student::getClassName,
                        Collectors.collectingAndThen(Collectors.toList(), arr -> {
                            return arr.stream()
                                    .sorted(Comparator.comparingInt(Student::getAge))
                                    .collect(Collectors.toList());
                        })
                )
        );
/*
輸出：
{
  計(jì)科 =[
    Student(id = 8, name = jerry, age = 12, sex = 男, className = 計(jì)科), 
    Student(id = 4, name = Dora, age = 14, sex = 女, className = 計(jì)科), 
    Student(id = 6, name = Farrah, age = 15, sex = 女, className = 計(jì)科), 
    Student(id = 9, name = Adam, age = 20, sex = 男, className = 計(jì)科)
  ],
  軟工 =[
    Student(id = 7, name = Helen, age = 13, sex = 女, className = 軟工), 
    Student(id = 2, name = lisa, age = 15, sex = 女, className = 軟工), 
    Student(id = 3, name = Ada, age = 16, sex = 女, className = 軟工), 
    Student(id = 1, name = tom, age = 19, sex = 男, className = 軟工), 
    Student(id = 5, name = Bob, age = 20, sex = 男, className = 軟工)
  ]
}
*/

Map<String, Long> map = studentList.stream()
        .collect(
                Collectors.groupingBy(
                        Student::getClassName,
                        Collectors.collectingAndThen(Collectors.toList(), arr -> {
                            return (long) arr.size();
                        })
                )
        );
/*
輸出：
{
  計(jì)科=4, 
  軟工=5
}
*/

Map<Integer, String> map = studentList.stream()
    .collect(Collectors.toMap(Student::getId, Student::getName));
System.out.println(map);
/*
輸出：
{
  1=tom, 
  2=lisa, 
  3=Ada, 
  4=Dora, 
  5=Bob, 
  6=Farrah, 
  7=Helen, 
  8=jerry, 
  9=Adam
}
*/

studentList.add(new Student(9, "Adam - 2", 20, "男", "計(jì)科"));

R apply(T t, U u);

Map<Integer, String> map = studentList.stream()
    .collect(Collectors.toMap(Student::getId, Student::getName, (v1, v2) -> {
        System.out.println("value1: " + v1);
        System.out.println("value2: " + v2);
        return v1;
    }));
/*
輸出：
value1: Adam
value2: Adam - 2
{1=tom, 2=lisa, 3=Ada, 4=Dora, 5=Bob, 6=Farrah, 7=Helen, 8=jerry, 9=Adam}
*/

// 參數(shù)意義： o 為原值(old)，n 為新值(new)
studentList.stream()
    // 保留策略
    .collect(Collectors.toMap(Student::getId, Student::getName, (o, n) -> o));


studentList.stream()
    // 覆蓋策略
    .collect(Collectors.toMap(Student::getId, Student::getName, (o, n) -> n));

studentList.add(new Student(10, null, 20, "男", "計(jì)科"));

Map<Integer, String> map = studentList.stream()
    .collect(Collectors.toMap(
        Student::getId,
        e -> Optional.ofNullable(e.getName()).orElse(""),
        (o, n) -> o
     ));
System.out.println(map);
/*
輸出：
{1=tom, 2=lisa, 3=Ada, 4=Dora, 5=Bob, 6=Farrah, 7=Helen, 8=jerry, 9=Adam, 10=}
*/
// 此時(shí)沒有空指針異常了

public final class Func {

    /**
     * 當(dāng) func 執(zhí)行結(jié)果為 null 時(shí), 返回 defaultValue
     *
     * @param func         轉(zhuǎn)換函數(shù)
     * @param defaultValue 默認(rèn)值
     * @return
     */
    public static <T, R> Function<T, R> defaultValue(@NonNull Function<T, R> func, @NonNull R defaultValue) {
        Objects.requireNonNull(func, "func不能為null");
        Objects.requireNonNull(defaultValue, "defaultValue不能為null");
        return t -> Optional.ofNullable(func.apply(t)).orElse(defaultValue);
    }

}

Map<Integer, String> map = studentList.stream()
    .collect(Collectors.toMap(
        Student::getId,
        Func.defaultValue(Student::getName, null),
        (o, n) -> o
    ));
System.out.println(map);

public final class CollUtils {

    /**
     * 過濾數(shù)據(jù)集合
     *
     * @param collection 數(shù)據(jù)集合
     * @param filter     過濾函數(shù)
     * @return
     */
    public static <T> List<T> filter(Collection<T> collection, Predicate<T> filter) {
        if (isEmpty(collection)) {
            return Collections.emptyList();
        }
        return collection.stream()
                .filter(filter)
                .collect(Collectors.toList());
    }

    /**
     * 獲取指定集合中的某個(gè)屬性
     *
     * @param collection 數(shù)據(jù)集合
     * @param attrFunc   屬性映射函數(shù)
     * @return
     */
    public static <T, R> List<R> attrs(Collection<T> collection, Function<T, R> attrFunc) {
        return attrs(collection, attrFunc, true);
    }

    /**
     * 獲取指定集合中的某個(gè)屬性
     *
     * @param collection  數(shù)據(jù)集合
     * @param attrFunc    屬性映射函數(shù)
     * @param filterEmpty 是否過濾空值 包括("", null, [])
     * @return
     */
    public static <T, R> List<R> attrs(Collection<T> collection, Function<T, R> attrFunc, boolean filterEmpty) {
        if (isEmpty(collection)) {
            return Collections.emptyList();
        }
        Stream<R> rStream = collection.stream().map(attrFunc);
        if (!filterEmpty) {
            return rStream.collect(Collectors.toList());
        }
        return rStream.filter(e -> {
            if (Objects.isNull(e)) {
                return false;
            }
            if (e instanceof Collection) {
                return !isEmpty((Collection<?>) e);
            }
            if (e instanceof String) {
                return ((String) e).length() > 0;
            }
            return true;
        }).collect(Collectors.toList());
    }


    /**
     * 轉(zhuǎn)換為map, 有重復(fù)key時(shí), 使用第一個(gè)值
     *
     * @param collection  數(shù)據(jù)集合
     * @param keyMapper   key映射函數(shù)
     * @param valueMapper value映射函數(shù)
     * @return
     */
    public static <T, K, V> Map<K, V> toMap(Collection<T> collection,
                                            Function<T, K> keyMapper,
                                            Function<T, V> valueMapper) {
        if (isEmpty(collection)) {
            return Collections.emptyMap();
        }
        return collection.stream()
                .collect(Collectors.toMap(keyMapper, valueMapper, (k1, k2) -> k1));
    }

    /**
     * 判讀集合為空
     *
     * @param collection 數(shù)據(jù)集合
     * @return
     */
    public static boolean isEmpty(Collection<?> collection) {
        return Objects.isNull(collection) || collection.isEmpty();
    }
}

// 獲取id集合
List<Integer> idList = studentList.stream()
    .map(Student::getId)
    .collect(Collectors.toList());
// 獲取id和name對(duì)應(yīng)的map
Map<Integer, String> map = studentList.stream()
    .collect(Collectors.toMap(Student::getId, Student::getName, (k1, k2) -> k1));
// 過濾出 軟工 班級(jí)的人員
List<Student> list = studentList.stream()
    .filter(e -> Objects.equals(e.getClassName(), "軟工"))
    .collect(Collectors.toList());

// 獲取id集合
List<Integer> idList = CollUtils.attrs(studentList, Student::getId);
// 獲取id和name對(duì)應(yīng)的map
Map<Integer, String> map = CollUtils.toMap(studentList, Student::getId, Student::getName);
// 過濾出 軟工 班級(jí)的人員
List<Student> list = CollUtils.filter(studentList, e -> Objects.equals(e.getClassName(), "軟工"));

List<String> allFemaleNameList = studentList.stream()
    .filter(stu -> Objects.equals("女", stu.getSex()))
    .map(Student::getName)
    .collect(Collectors.toList());
System.out.println(allFemaleNameList);
// 這樣寫 .filter 和 .map 的函數(shù)表達(dá)式中報(bào)錯(cuò)可以看出來是那一行

List<String> allFemaleNameList = studentList.stream().filter(stu -> Objects.equals("女", stu.getSex())).map(Student::getName).collect(Collectors.toList());
System.out.println(allFemaleNameList);