Java - Lambda 和 Stream

1 Lambda 表达式标准格式

Lambda 表达式是一个匿名函数，Lambda 表达式标准格式：函数形参 -> 函数体。如果有多个函数形参，参数之间用逗号隔开；如果没有参数，使用 () 代替。

2 Lambda 表达式应用场景

2.1 集合遍历

使用传统的 for-each 循环遍历列表并打印每个元素：

public class TraditionalForEach {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("a", "b", "c");
        for (String item : list) {
            System.out.println("传统方式遍历元素: " + item);
        }
    }
}

使用 lambda 表达式遍历列表并打印每个元素：

public class LambdaForEach {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("a", "b", "c");
        list.forEach(item -> System.out.println("Lambda方式遍历元素: " + item));
    }
}

2.2 集合排序

使用传统方式进行排序：

public class TraditionalSort {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("b", "a", "c");
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.compareTo(s2);
            }
        });
        
        System.out.println("传统方式排序结果: " + list);
    }
}

使用 lambda 表达式进行排序：

import java.util.Arrays;
import java.util.List;

public class LambdaSort {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("b", "a", "c");
        list.sort((s1, s2) -> s1.compareTo(s2));
        System.out.println("Lambda方式排序结果: " + list);
    }
}

2.3 集合过滤

使用传统方式进行过滤：

public class TraditionalFilter {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("a", "b", "c", "aa");
        List<String> filteredList = new ArrayList<>();
        for (String item : list) {
            if (item.startsWith("a")) {
                filteredList.add(item);
            }
        }
        System.out.println("传统方式过滤结果: " + filteredList);
    }
}

使用 lambda 表达式进行过滤并收集结果：

public class LambdaFilter {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("a", "b", "c", "aa");
        List<String> filteredList = list.stream()
                                        .filter(item -> item.startsWith("a"))
                                        .collect(Collectors.toList());
        System.out.println("Lambda方式过滤结果: " + filteredList);
    }
}

2.4 集合映射

使用传统方式进行映射：

public class TraditionalMap {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("1", "2", "3");
        List<Integer> mappedList = new ArrayList<>();
        for (String item : list) {
            mappedList.add(Integer.parseInt(item));
        }
        System.out.println("传统方式映射结果: " + mappedList);
    }
}

使用 lambda 表达式进行映射并收集结果：

public class LambdaMap {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("1", "2", "3");
        List<Integer> mappedList = list.stream()
                                       .map(Integer::parseInt)
                                       .collect(Collectors.toList());
        System.out.println("Lambda方式映射结果: " + mappedList);
    }
}

3 Stream 流

Stream 流不存储数据，而是按照特定的中间操作处理数据，在不改变数据源的情况下产生一个新的集合或一个值。

3.1 创建流

3.1.1 集合创建流

集合创建的流分为顺序流和并行流。顺序流由主线程按顺序对流执行操作，而并行流内部以多线程并行执行的方式对流进行操作，但前提是流中的数据处理没有顺序要求。一般如果数据量不是很大的话，尽量使用顺序流。

List<String> list = Arrays.asList("a", "b", "c");
// 创建一个顺序流 
Stream<String> stream = list.stream();
// 创建一个并行流
Stream<String> parallelStream = list.parallelStream();

3.1.2 数组创建流

int[] array = {1,3,5,6,8};
IntStream stream = Arrays.stream(array);

3.1.3 Stream 的静态方法创建流

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
Stream<Double> stream3 = Stream.generate(Math::random).limit(3);

3.2 中间操作

Stream 的中间操作方法支持链式调用。

方法	描述
distinct()	返回去除重复元素后的新流
limit(long maxSize)	截断流，使元素不超过给定数量 maxSize
skip(long n)	返回一个去除了前 n 个元素的流，若流中元素不足 n 个则返回一个空流
filter(Predicatep)	返回满足 Lambda 表达式指定元素的新流
map(Function f)	接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
mapToInt(ToIntFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 IntStream
flatMap(Function f)	接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
sorted()	产生一个按自然顺序排序的新流
sorted(Comparator com)	产生一个按比较器 com 顺序排序的新流

public class StreamTest {
    @Test
    public void test1(){
        Stream.of(1,2,3,4,5,6)
                .filter(t -> t%2 == 0)
                .forEach(System.out::print);
    }
    
    @Test
    public void test2(){
        Stream.of(1,2,2,2,3,3)
                .distinct()
                .forEach(System.out::print);
    }
    
    @Test
    public void test3(){
        Stream.of(1,2,3,4,5,6)
                .limit(3)
                .forEach(System.out::print);
    }
    
    @Test
    public void test4(){
        Stream.of(1,2,2,3,3,5,2,3,5,6,7)
                .distinct()              
                .filter(t -> t % 2 != 0) 
                .limit(2)
                .forEach(System.out::print);
    }
    
    @Test
    public void test5(){
        Stream.of(1,2,3,4,5,6)
                .skip(5)
                .forEach(System.out::print);
    }
    
    @Test
    public void test6(){
        // 如果要降序排列 sorted((t1,t2) -> Integer.compare(t2, t1))
        Stream.of(3,9,1,6,2,7,8)
                .sorted() 
                .forEach(System.out::print);
    }
    
    @Test
    public void test7(){
        Stream.of(1,2,3,4,5)
                .map(t -> t += 1)
                .forEach(System.out::print);
    }
    
    @Test
    public void test8(){
        String[] arr = {"hello","world","java"};
        Arrays.stream(arr)
                .map(String::toUpperCase)
                .forEach(System.out::println);
    }
   
}

3.3 终止操作

流进行了终止操作后，就不能再次使用。

方 法	描 述
allMatch(Predicate p)	检查是否匹配所有元素，返回
anyMatch(Predicate p)	检查是否至少匹配一个元素
noneMatch(Predicate p)	检查是否没有匹配所有元素
findFirst()	返回第一个元素，如果没有返回 Optional.empty
findAny()	返回当前流中的任意元素
count()	返回流中元素总数
max / min(Comparator c)	返回流中最大值 / 最小值
sorted()	产生一个按自然顺序排序的新流
reduce(BinaryOperator b)	可以将流中元素反复结合起来，得到一个值 Optional
forEach(System.out::println)	迭代打印
collect(Collectors.toList())	把流中元素收集到 List
collect(Collectors.toSet())	把流中元素收集到 Set