Stream流的中间方法详解
Stream流的中间方法指那些返回新Stream的操作，允许链式调用。这些方法通常用于数据过滤、映射、排序等操作，不会触发最终计算。
filter方法
filter用于筛选满足条件的元素，接受一个Predicate函数式接口参数。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> evenNumbers = numbers.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());
// 输出: [2,4]
map方法
map用于元素转换，接受Function接口参数，将元素映射为另一种形式。
List<String> names = Arrays.asList("Alice", "Bob");
List<Integer> nameLengths = names.stream()
.map(String::length)
.collect(Collectors.toList());
// 输出: [5,3]
flatMap方法
flatMap用于将嵌套结构扁平化，每个元素转换为新的Stream后合并。
List<List<Integer>> nestedNumbers = Arrays.asList(
Arrays.asList(1,2),
Arrays.asList(3,4));
List<Integer> flattened = nestedNumbers.stream()
.flatMap(List::stream)
.collect(Collectors.toList());
// 输出: [1,2,3,4]
distinct方法
distinct去除重复元素，依赖元素的equals方法。
List<Integer> duplicates = Arrays.asList(1,2,2,3);
List<Integer> unique = duplicates.stream()
.distinct()
.collect(Collectors.toList());
// 输出: [1,2,3]
sorted方法
sorted用于排序，可自然排序或提供Comparator。
List<String> unsorted = Arrays.asList("Bob", "Alice");
List<String> sorted = unsorted.stream()
.sorted()
.collect(Collectors.toList());
// 输出: ["Alice","Bob"]
List<Integer> numbers = Arrays.asList(3,1,2);
List<Integer> customSorted = numbers.stream()
.sorted(Comparator.reverseOrder())
.collect(Collectors.toList());
// 输出: [3,2,1]
limit方法
limit截取前N个元素。
List<Integer> numbers = Arrays.asList(1,2,3,4,5);
List<Integer> firstThree = numbers.stream()
.limit(3)
.collect(Collectors.toList());
// 输出: [1,2,3]
skip方法
skip跳过前N个元素。
List<Integer> numbers = Arrays.asList(1,2,3,4,5);
List<Integer> afterTwo = numbers.stream()
.skip(2)
.collect(Collectors.toList());
// 输出: [3,4,5]
peek方法
peek用于调试，允许查看流经的元素但不修改。
List<String> names = Arrays.asList("Alice", "Bob");
List<String> result = names.stream()
.peek(System.out::println)
.map(String::toUpperCase)
.collect(Collectors.toList());
// 输出调试信息: Alice Bob
// 最终结果: ["ALICE","BOB"]
实例一：
public class StreamDemo6 {
public static void main(String[] args) {
/*
filter 过滤
limit 获取前几个元素
skip 跳过前几个元素
注意1：中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程
注意2：修改Stream流中的数据，不会影响原来集合或者数组中的数据
*/
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");
//filter 过滤 把张开头的留下，其余数据过滤不要
/*list.stream().filter(new Predicate<String>() {
@Override
public boolean test(String s) {
//如果返回值为true，表示当前数据留下
//如果返回值为false，表示当前数据舍弃不要
return s.startsWith("张");
}
}).forEach(s -> System.out.println(s));
list.stream()
.filter(s -> s.startsWith("张"))
.filter(s -> s.length() == 3)
.forEach(s -> System.out.println(s));
System.out.println("====================================");
System.out.println(list);*/
/* limit 获取前几个元素
skip 跳过前几个元素*/
//"张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤"
//list.stream().limit(3).forEach(s -> System.out.println(s));
//list.stream().skip(4) .forEach(s -> System.out.println(s));
//课堂练习：
//"张强", "张三丰", "张翠山"
//第一种思路：
//先获取前面6个元素："张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山",
//然后跳过前面3个元素
//list.stream().limit(6).skip(3).forEach(s -> System.out.println(s));
//第二种思路：
//先跳过3个元素："张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤"
//然后再获取前面3个元素："张强", "张三丰", "张翠山"
//list.stream().skip(3).limit(3).forEach(s -> System.out.println(s));
}
}
实例二：
public class StreamDemo7 {
public static void main(String[] args) {
/*
distinct 元素去重，依赖(hashCode和equals方法)
concat 合并a和b两个流为一个流
注意1：中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程
注意2：修改Stream流中的数据，不会影响原来集合或者数组中的数据
*/
ArrayList<String> list1 = new ArrayList<>();
Collections.addAll(list1, "张无忌","张无忌","张无忌", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");
ArrayList<String> list2 = new ArrayList<>();
Collections.addAll(list2, "周芷若", "赵敏");
// distinct 元素去重，依赖(hashCode和equals方法)
//list1.stream().distinct().forEach(s -> System.out.println(s));
Stream.concat(list1.stream(),list2.stream()).forEach(s -> System.out.println(s));
}
}
实例三：
public class StreamDemo8 {
public static void main(String[] args) {
/*
map 转换流中的数据类型
注意1：中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程
注意2：修改Stream流中的数据，不会影响原来集合或者数组中的数据
*/
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌-15", "周芷若-14", "赵敏-13", "张强-20", "张三丰-100", "张翠山-40", "张良-35", "王二麻子-37", "谢广坤-41");
//需求：只获取里面的年龄并进行打印
//String->int
//第一个类型：流中原本的数据类型
//第二个类型：要转成之后的类型
//apply的形参s：依次表示流里面的每一个数据
//返回值：表示转换之后的数据
//当map方法执行完毕之后，流上的数据就变成了整数
//所以在下面forEach当中，s依次表示流里面的每一个数据，这个数据现在就是整数了
list.stream().map(new Function<String, Integer>() {
@Override
public Integer apply(String s) {
String[] arr = s.split("-");
String ageString = arr[1];
int age = Integer.parseInt(ageString);
return age;
}
}).forEach(s-> System.out.println(s));
System.out.println("------------------------");
list.stream()
.map(s-> Integer.parseInt(s.split("-")[1]))
.forEach(s-> System.out.println(s));
}
}
注意：中间操作具有延迟特性，只有遇到终端操作时才会执行。多个中间操作可以组合形成处理流水线。