Java的Stream入门级教程

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

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

int sum = evenNumbers.reduce(0, Integer::sum);  // 终止操作，执行计算

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()//获取源数据
                .filter(p -> p.age > 18)//过滤源数据,满足条件则true则就保留
                .map(person -> person.name)//做map映射就是将这个源数据中的每个数据转换成另外一种数据,
                // 在这里面就是将每个对象转换成他们对应的名字
                .collect(Collectors.toList());//收集处理后的数据,通过列表的方式
        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()//转为流数据
                .collect(Collectors.groupingBy(Person::getCity, Collectors.counting()));
        //这个的作用是将这个流中的数据做一个分组,key是city,value是key对应的数量Collectors.counting() 是一个下游收集器，用来统计分组后的元素数量。
        //它返回一个 Long 类型的值，表示每个分组中元素的数量。在这里，它会统计每个城市中有多少个 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是将收集的数据进行分组根据city属性，他收集出来就是一个map，但是这个map的value不是一个值
        //而是一个对象这个对象是一个分区的函数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);//然后通过年龄进行比较
        List<Person> sorted = people.stream()
                .sorted(byCityThenAge)//通过比较类进行排序
                .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);

// 按年龄排序，使用静态方法 Comparator.comparing
people.sort(Comparator.comparing(Person::getAge)); // 按年龄升序

// 使用 Lambda 表达式简化比较逻辑
Collections.sort(people, (p1, p2) -> Integer.compare(p1.getAge(), p2.getAge())); // 按年龄升序