目录
一、Stream API的理解:
1.1 Stream关注
1.2 java8的api
二、简介
三、Stream实例化
四、中间操作
五、终止操作
六、Stream的常用案例
1.steam将list集合转set集合
2.steam将list集合转map集合
3.steam计算求和
4.steam查找最值
5.stream过滤器
6.stream的match
7.stream实现排序
8.stream Limit和skip
9.组合案例
10.并行流
一、Stream API的理解:
1.1 Stream关注
是对数据的运算,与CPU打交道,集合关注的是数据的存储,与内存打交道
1.2 java8的api
使用这套api可以对内存中的数据进行过滤、排序、映射、归约等操作。类似于sql对数据库中表的相关操作。
二、简介
流(Stream)是 Java 8 引入的一种处理集合数据的抽象概念,它提供了一种更简洁、更灵活的方式来操作和处理集合数据。流可以看作是一系列元素的管道,可以对这些元素进行筛选、转换、排序、归约等操作,实现各种数据处理需求。与传统的循环迭代方式相比,流的代码更易读、更易于并行化处理,并且能够充分发挥多核处理器的优势。通过使用流,可以提高代码的可读性和可维护性,同时也能够更高效地处理大规模数据集合。
三、Stream实例化
//创建 Stream方式一:通过集合@Testpublic void test1(){List<Employee> employees = EmployeeData.getEmployees();// default Stream<E> stream() : 返回一个顺序流Stream<Employee> stream = employees.stream();// default Stream<E> parallelStream() : 返回一个并行流Stream<Employee> parallelStream = employees.parallelStream();}//创建 Stream方式二:通过数组@Testpublic void test2(){int[] arr = new int[]{1,2,3,4,5,6};//调用Arrays类的static <T> Stream<T> stream(T[] array): 返回一个流IntStream stream = Arrays.stream(arr);Employee e1 = new Employee(1001,"Tom");Employee e2 = new Employee(1002,"Jerry");Employee[] arr1 = new Employee[]{e1,e2};Stream<Employee> stream1 = Arrays.stream(arr1);}//创建 Stream方式三:通过Stream的of()@Testpublic void test3(){Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);}//创建 Stream方式四:创建无限流@Testpublic void test4(){// 迭代
// public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)//遍历前10个偶数Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);// 生成
// public static<T> Stream<T> generate(Supplier<T> s)Stream.generate(Math::random).limit(10).forEach(System.out::println);}
四、中间操作
五、终止操作
Collector需要使用Collectors提供实例。
六、Stream的常用案例
1.steam将list集合转set集合
public static void main(String [] args){List<Student> students=Arrays.asList(new Student("小明",18),new Student("小黑",16),new Student("小红",17));//转成流并进行set集合转换Set<Student> sets=students.stream().collect(Collectors.toSet());//集合遍历sets.forEach(stu->System.out.println(stu.toString()));}
在上面的示例中,我们首先创建了一个 List 集合 list,包含了三个对象。然后使用 stream 方法将其转换为流,接着使用 collect 方法将流中的元素收集到一个 Set 集合中,使用 Collectors.toSet() 指定要收集到的集合类型。最终得到了一个包含唯一元素的 Set 集合。
注意:转成set集合需要重写实体类Student的equals 方法和 hashCode 方法。
2.steam将list集合转map集合
在上面的示例中,我们首先创建了一个包含学生对象的 List<Student> 集合 students。然后使用 stream 方法将其转换为流,接着使用 collect 方法将流中的元素收集到一个 Map 集合中,使用 Collectors.toMap() 指定键和值的提取方式。在这里,我们使用学生对象的姓名作为键,学生对象本身作为值。
3.steam计算求和
public static void main(String[] args) {List<Student> students= Arrays.asList(new Student("小明",18),new Student("小黑",16),new Student("小红",17));//创建流并累加年龄int sum=students.stream().mapToInt(Student::getAge).sum();System.out.println(sum);}
4.steam查找最值
public static void main(String[] args) {List<Student> students= Arrays.asList(new Student("小明",18),new Student("小黑",16),new Student("小红",17));//找出年龄最大的人Optional<Student> max=students.stream().max((o1, o2)->o1.getAge()-o2.getAge());System.out.println(max);//找出年龄最小的人Optional<Student> min=students.stream().min((o1, o2)->o1.getAge()-o2.getAge());System.out.println(min);
}
5.stream过滤器
filter 方法接受一个 Predicate 参数,该参数是一个函数式接口,用于指定过滤条件。filter 方法会根据条件筛选出流中符合条件的元素,并返回一个新的流。
public static void main(String[] args) {List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);// 过滤并打印出所有偶数Stream<Integer> evenNumbers = numbers.stream().filter(n -> n % 2 == 0);evenNumbers.forEach(System.out::println);
}
6.stream的match
match 方法用于判断流中的元素是否符合指定的条件,并返回一个布尔值。
match 方法有三个变种:
- allMatch 方法:判断流中的所有元素是否都符合指定的条件,如果都符合,返回 true,否则返回 false。
- anyMatch 方法:判断流中是否存在任意一个元素符合指定的条件,如果有,返回 true,否则返回 false。
- noneMatch 方法:判断流中是否不存在任何一个元素符合指定的条件,如果没有,返回 true,否则返回 false。
public static void main(String[] args) {List<Student> students= Arrays.asList(new Student("小明",18),new Student("小黑",16),new Student("小红",17));// 判断所有学生年龄是否都大于17boolean match = students.stream().allMatch(s -> s.getAge() > 17);System.out.println(match);//false//判断只要有一个学生年龄小于17boolean match1 = students.stream().anyMatch(s -> s.getAge() < 17);System.out.println(match1);//true//判断没有一个学生年龄大于18boolean match2 = students.stream().noneMatch(s -> s.getAge() > 18);System.out.println(match2);//true
}
7.stream实现排序
public static void main(String[] args) {// 创建一个包含整数的StreamStream<Integer> stream1 = Stream.of(3, 1, 4, 1, 5, 9);Stream<Integer> stream2 = Stream.of(3, 1, 4, 1, 5, 9);// 使用sorted()方法对Stream1进行升序排序(默认)Stream<Integer> sortedStream = stream1.sorted();sortedStream.forEach(System.out::println);System.out.println("-----------------------------------------------");// 使用sorted()方法对Stream2进行降序排序Stream<Integer> sortedDescStream = stream2.sorted((a, b) -> b.compareTo(a));sortedDescStream.forEach(System.out::println);
}
8.stream Limit和skip
Stream 类提供了 limit 和 skip 方法,用于限制流中元素的数量。
1.limit 方法:该方法用于截取流中的前 n 个元素,并返回一个新的流。如果流中的元素不足 n 个,则返回包含所有元素的流。
public static void main(String[] args) {List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);// 获取前3个元素Stream<Integer> limitedStream = numbers.stream().limit(3);limitedStream.forEach(System.out::println);
}
2.skip 方法:该方法用于跳过流中的前 n 个元素,并返回一个新的流。如果流中的元素不足 n 个,则返回一个空的流。
public static void main(String[] args) {List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);//跳过前两个元素Stream<Integer> skipStream = numbers.stream().skip(2);skipStream.forEach(System.out::println);}
一般我们会通过limit方法和skip搭配进行分页截取
public static void main(String[] args) {List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5,6,7,8,9,10);//一页五个截取第二页Stream<Integer> skipLimitStream = numbers.stream().skip(5).limit(5);skipLimitStream.forEach(System.out::println);
}
9.组合案例
我们来看一个需求
对给定的学生列表按照年龄降序排列并查找姓张的,获取前3位
public static void main(String[] args) {List<Student> students= Arrays.asList(new Student("张明",18),new Student("李黑",16),new Student("王红",17),new Student("张三",36),new Student("李四",27),new Student("刘备",56),new Student("关羽",47),new Student("张飞",49),new Student("张同",17),new Student("张良",41));//降序排序--查找姓张的--截取前三位students.stream().sorted((s1,s2)->s2.getAge()-s1.getAge()).filter(s->s.getName().startsWith("张")).limit(3).forEach(System.out::println);System.out.println("-----------------------------------------------");
}
通过对流进行一系列的中间操作就可以完成这个需求,这种链式调用可以使代码非常简洁。
10.并行流
Stream 类提供了并行流的支持,可以通过 parallel 方法将一个顺序流转换为并行流。并行流可以充分利用多核处理器的优势,将流中的元素进行并发处理,从而提高处理效率。
前面所有流的示例都是顺序流(单线程),有时在面对较大的数据处理单线程效率太慢,我们就可以使用并行流(多线程)进行优化。
来看一个需求,求1-1亿的累加和,分别用单线程的顺序流跟多线程的并行流来看执行效率。
public static void main(String[] args) {// 顺序流计算long start = System.currentTimeMillis();int sum = IntStream.rangeClosed(1, 1000000000).sum();long end = System.currentTimeMillis();System.out.println("顺序流计算结果:" + sum + ",耗时:" + (end - start) + " 毫秒");// 并行流计算start = System.currentTimeMillis();sum = IntStream.rangeClosed(1, 1000000000).parallel().sum();end = System.currentTimeMillis();System.out.println("并行流计算结果:" + sum + ",耗时:" + (end - start) + " 毫秒");
}
可以看到执行效率还是有明显提升的。