List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> stream = numbers.stream();  // 創(chuàng)建流

Stream<Integer> evenNumbers = stream.filter(n -> n % 2 == 0)  // 中間操作
                                   .map(n -> n * n);          // 另一個中間操作

int sum = evenNumbers.reduce(0, Integer::sum);  // 終止操作，執(zhí)行計算

public class Person {
    public String name;
    public int age;
    public String city;
    public Person(String name,int age,String city){
        this.name = name;
        this.age = age;
        this.city = city;
    }
}

import java.util.List;
import java.util.stream.Collectors;
public class StreamTest {
    public static void main(String []str){
        List<Person> people = List.of(
                new Person("Alice", 23, "Beijing"),
                new Person("Bob", 17, "Shanghai"),
                new Person("Carol", 30, "Beijing")
        );
        //提取大于18歲的對象的名字
        List<String> collect = people.stream()//獲取源數(shù)據(jù)
                .filter(p -> p.age > 18)//過濾源數(shù)據(jù),滿足條件則true則就保留
                .map(person -> person.name)//做map映射就是將這個源數(shù)據(jù)中的每個數(shù)據(jù)轉(zhuǎn)換成另外一種數(shù)據(jù),
                // 在這里面就是將每個對象轉(zhuǎn)換成他們對應(yīng)的名字
                .collect(Collectors.toList());//收集處理后的數(shù)據(jù),通過列表的方式
        System.out.println(collect);
    }
}

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class StreamTest {
    public static void main(String []str){
        List<Person> people = List.of(
                new Person("Alice", 23, "Beijing"),
                new Person("Bob", 17, "Shanghai"),
                new Person("Carol", 30, "Beijing"),
                new Person("Dave", 25, "Shanghai"),
                new Person("Eve", 22, "Beijing")
        );
        Map<String, Long> collect = people.stream()//轉(zhuǎn)為流數(shù)據(jù)
                .collect(Collectors.groupingBy(Person::getCity, Collectors.counting()));
        //這個的作用是將這個流中的數(shù)據(jù)做一個分組,key是city,value是key對應(yīng)的數(shù)量Collectors.counting() 是一個下游收集器，用來統(tǒng)計分組后的元素數(shù)量。
        //它返回一個 Long 類型的值，表示每個分組中元素的數(shù)量。在這里，它會統(tǒng)計每個城市中有多少個 Person 對象。
        System.out.println(collect);
    }
}

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class StreamTest {
    public static void main(String []str){
        List<Person> people = List.of(
                new Person("Alice", 23, "Beijing"),
                new Person("Bob", 17, "Shanghai"),
                new Person("Carol", 30, "Beijing"),
                new Person("Dave", 25, "Shanghai"),
                new Person("Eve", 22, "Beijing")
        );
        Map<String, Map<Boolean, List<Person>>> collect = people.stream()
                .collect(Collectors.groupingBy(Person::getCity, Collectors.partitioningBy(p -> p.age > 18)));
                //這里面的Collectors.groupingBy是將收集的數(shù)據(jù)進(jìn)行分組根據(jù)city屬性，他收集出來就是一個map，但是這個map的value不是一個值
        //而是一個對象這個對象是一個分區(qū)的函數(shù)partitioningBy他會將value又分成一個map將滿足條件的放一組,不滿足的放一組來形成一個map
        System.out.println(collect);
    }

import java.util.Arrays;
import java.util.List;
public class StreamTest {
    public static void main(String []str){
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        int sum = numbers.stream()
                .reduce(0, (a, b) -> a + b);  // 0 是初始值，(a, b) -> a + b 是累加器
        System.out.println(sum);  // 輸出 15
    }
}

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> max = numbers.stream()
                               .reduce(Integer::max);  // 使用 Integer::max 方法引用
max.ifPresent(System.out::println);  // 輸出 5

List<String> words = Arrays.asList("Java", "is", "awesome");
String result = words.stream()
                     .reduce("", (a, b) -> a + " " + b);  // 初始值為空字符串
System.out.println(result);  // 輸出 "Java is awesome"

IntSummaryStatistics stats = people.stream()
    .collect(Collectors.summarizingInt(Person::age));
// stats.getCount()/getSum()/getMin()/getMax()/getAverage()

import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class StreamTest {
    public static void main(String []str){
        List<Person> people = List.of(
                new Person("Alice", 23, "Beijing"),
                new Person("Bob", 17, "Shanghai"),
                new Person("Carol", 30, "Beijing"),
                new Person("Dave", 25, "Shanghai"),
                new Person("Eve", 22, "Beijing")
        );
        Comparator<Person> byCityThenAge = Comparator
                .comparing(Person::getCity, Comparator.nullsLast(String::compareTo))//定義比較類先是通過city排序，對于null的排到最后
                .thenComparingInt(Person::getAge);//然后通過年齡進(jìn)行比較
        List<Person> sorted = people.stream()
                .sorted(byCityThenAge)//通過比較類進(jìn)行排序
                .collect(Collectors.toList());
        System.out.println(sorted);
    }
}

List<Person> people = Arrays.asList(
    new Person("John", 25),
    new Person("Alice", 30),
    new Person("Bob", 20)
);

// 按名字排序，如果名字相同再按年齡排序
people.sort(Comparator.comparing(Person::getName)
                      .thenComparing(Person::getAge));

// 按年齡降序排序
people.sort(Comparator.comparing(Person::getAge).reversed());

List<String> strings = Arrays.asList("apple", "banana", null, "cherry", null);
strings.sort(Comparator.nullsLast(Comparator.naturalOrder())); // 排序時，null 值排在最后
strings.forEach(System.out::println);

// 按年齡排序，使用靜態(tài)方法 Comparator.comparing
people.sort(Comparator.comparing(Person::getAge)); // 按年齡升序

// 使用 Lambda 表達(dá)式簡化比較邏輯
Collections.sort(people, (p1, p2) -> Integer.compare(p1.getAge(), p2.getAge())); // 按年齡升序