public class LambdaUseCase {
    static List<Department> departmentList;
    static {
        // 一級(jí)部門(mén),部門(mén)人員有001號(hào)員工小明
        Department departmentOne = new Department("一級(jí)部門(mén)", 1,10000L,11000L,
                Arrays.asList(new Person("001","小明",22)));
        // 二級(jí)部門(mén)甲,部門(mén)人員有002號(hào)員工小剛和003號(hào)員工小李
        Department departmentTwoFirst = new Department("二級(jí)部門(mén)甲", 2,8000L,13000L,
                Arrays.asList(new Person("002","小剛",23),
                        new Person("003","小李",32)));
        // 二級(jí)部門(mén)乙，部門(mén)人員有002號(hào)員工小剛和004號(hào)員工小張
        Department departmentTwoSecond = new Department("二級(jí)部門(mén)已", 2,7500L,15000L,
                Arrays.asList(new Person("002","小剛",23),
                        new Person("004","小張",34)));

        departmentList = Arrays.asList(departmentOne,departmentTwoFirst,departmentTwoSecond);
    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class Department {
    // 部門(mén)名
    private String departmentName;
    // 部門(mén)等級(jí)
    private Integer departmenRank;
    // 部門(mén)薪資（單位分）
    private Long departSalary;
    // 部門(mén)日盈利
    private Long departProfit;
    // 部門(mén)人員集合
    private List<Person> persons;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
//重寫(xiě)equal和hashcode方法，用于數(shù)據(jù)去重
@EqualsAndHashCode
class Person {
    // 人員id
    private String personId;
    // 人員姓名
    private String personName;
    // 人員年齡
    private Integer personAge;
}

departmentList.stream();

Integer[] arr = {1,2,3,4,5};
Stream<Integer> stream = Arrays.stream(arr);
Stream<Integer> stream2 = Stream.of(arr);
Stream.of(1,2,3,4);

Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);
Stream<Map.Entry<String, Integer>> stream = map.entrySet().stream();

List<Department> departments = departmentList.stream().map(e -> {
    e.setDepartSalary(e.getDepartSalary() + 1000);
    return e;
}).collect(Collectors.toList());

List<Department> departments = departmentList.stream()
		.filter(e -> e.getDepartSalary() >= 8000)
		.collect(Collectors.toList());

Set<Person> personSet = new HashSet<>();
departmentList.stream().forEach(e->{
	e.getPersons().stream().forEach(person->{
		personSet.add(person);
	});
});

Set<Person> personSet = departmentList.stream()
        .flatMap(e -> e.getPersons().stream())
        .collect(Collectors.toSet());

List<Person> personSet = departmentList.stream()
        .flatMap(e -> e.getPersons().stream())
        .distinct()
        .collect(Collectors.toList());

List<Department> departments = departmentList.stream()
        .sorted((o1, o2) -> o1.getDepartSalary().compareTo(o2.getDepartSalary()))
        .collect(Collectors.toList());

List<Department> departments = departmentList.stream()
		.sorted(Comparator.comparing(Department::getDepartSalary))
		.limit(2)
		.collect(Collectors.toList());

List<Department> departments = departmentList.stream()
		.sorted(Comparator.comparing(Department::getDepartSalary))
		.skip(1)
		.collect(Collectors.toList());

departmentList.stream()
                .forEach(e -> System.out.println(e.getDepartmentName()));

long count = departmentList.stream()
    .count();

Department maxDepartment = departmentList.stream()
		.max(Comparator.comparing(Department::getDepartSalary))
		.get();
Department minDepartment = departmentList.stream()
		.min(Comparator.comparing(Department::getDepartSalary))
		.get();

List<String> departNameList = departmentList.stream()
		.map(Department::getDepartmentName)
		.collect(Collectors.toList());

Set<String> personNameList = departmentList.stream()
		.flatMap(e -> e.getPersons().stream())
		.map(Person::getPersonName)
        .collect(Collectors.toSet());

Map<String, List<Person>> collect = departmentList.stream()
		.collect(Collectors.toMap(Department::getDepartmentName, Department::getPersons));

departmentList.stream()
		.map(Department::getDepartmentName)
		.collect(Collectors.joining(",","[","]"));

Map<Boolean, List<Department>> collect = departmentList
    .stream()
    .collect(Collectors.partitioningBy(e -> e.getDepartmenRank() == 1));

Map<Integer, List<Department>> collect = departmentList
    .stream()
    .collect(Collectors.groupingBy(Department::getDepartmenRank));

Map<Integer, Double> collect = departmentList.stream()
.collect(Collectors.groupingBy(Department::getDepartmenRank,Collectors.averagingLong(Department::getDepartSalary)));

Long sum = departmentList.stream()
		.map(Department::getDepartProfit)
		.reduce(0L, (result, element) -> result + element);

boolean b = departmentList.stream()
                .anyMatch(e -> e.getDepartSalary() > 9000L);

boolean b = departmentList.stream()
                .allMatch(e -> e.getDepartSalary() > 9000L);

boolean b = departmentList.stream()
                .noneMatch(e -> e.getDepartSalary() > 9000L);

Department department = departmentList
                .stream()
                .findAny()
                .get();

Department department = departmentList
                .stream()
                .sorted(Comparator.comparing(Department::getDepartSalary))
                .findFirst()
                .get();

LongSummaryStatistics longSummaryStatistics = departmentList
    .stream()
    .mapToLong(Department::getDepartProfit)
    .summaryStatistics();
System.out.println("利潤(rùn)最大值"+longSummaryStatistics.getMax());
System.out.println("利潤(rùn)最小值"+longSummaryStatistics.getMin());
System.out.println("利潤(rùn)平均值"+longSummaryStatistics.getAverage());
System.out.println("利潤(rùn)總和"+longSummaryStatistics.getSum());

Set<Person> collect = departmentList.stream()
		.parallel()
		.flatMap(e -> e.getPersons().stream()).collect(Collectors.toSet());
Set<Person> collect1 = departmentList.parallelStream()
		.flatMap(e -> e.getPersons().stream()).collect(Collectors.toSet());