stream流_Stream流的这些操作，你得知道，对你工作有很大帮助

Stream流

Stream（流）是一个来自数据源的元素队列并支持聚合操作：

元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
数据源流的来源。可以是集合，数组等。
聚合操作类似SQL语句一样的操作，比如filter, map, reduce, find, match, sorted 等。

Stream流操作的三个步骤：

创建Stream
一个数据源(如：集合、数组)，获取一个流
中间操作
一个中间操作链，对数据源的数据进行处理
终止操作
一个终止操作，执行中间操作链，并产生结果

创建Stream步骤：

通过Collection系列集合提供的顺序流stream()或并行流parallelStream()
通过Arrays中的静态方法stream()获取数据流
通过Stream类中的静态方法of()

代码实例：

package com.ysh.review01_Stream;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;public class StreamTest01 {public static void main(String[] args) {//第一种方式：通过集合中的stream()方法创建StreamList<String> list= Arrays.asList("红太狼","灰太狼","喜羊羊");Stream<String> stream=list.stream();//通过集合中的parallelStream方法创建Stream<String> stream2 = list.parallelStream();//第二种方式：通过java.util.Arrays下的静态方法stream创建StreamInteger[] integer=new Integer[]{1,2,4};//这里需要注意的是Arrays中的stream方法里面的参数需要一个数组，且数组的类型是一个引用类型或者是一个包装类Stream<Integer> stream3 = Arrays.stream(integer);//第三种方式：通过Stream中的of方法,实际上这种方式创建Stream实际上间接的通过调用Arrays中的stream()静态方法Stream<String> stream4=Stream.of("a","b","c");}
}

Stream的中间操作

筛选和切片

filter：过滤器

package com.ysh.review01_Stream;import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;public class StramTest02 {public static void main(String[] args) {Employee employee01=new Employee("yang","hui",29);Employee employee02=new Employee("yang","hui",49);Employee employee03=new Employee("yang","hui",9);Employee employee04=new Employee("yang","hui",89);Employee employee05=new Employee("yang","hui",89);Employee employee06=new Employee("yang","hui",89);List<Employee> list= Arrays.asList(employee01,employee02,employee03,employee04,employee05,employee06);//创建StreamStream<Employee> stream1 = list.stream();//对stream1流进行过滤Stream<Employee> s = stream1.filter((e) -> {System.out.println("---------------filter------------");//过滤掉年龄小于19return e.getAge() >= 19;});s.forEach((e-> System.out.println(e)));}
}
class Employee {private String id;private String name;private int age;public Employee() {}public Employee(String id, String name, int age) {this.id = id;this.name = name;this.age = age;}public String getId() {return id;}public void setId(String id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Employee employee = (Employee) o;return age == employee.age &&id.equals(employee.id) &&name.equals(employee.name);}@Overridepublic String toString() {return "Employee{" +"id='" + id + ''' +", name='" + name + ''' +", age=" + age +'}';}
}

运行结果：

skip(n):指跳过Stream中存储的前n条数据(包含第n条数据)，返回后n条数据，如果n大于Stream中所有元素的个数，则返回空；(Employee类如上)

package com.ysh.review01_Stream;import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;public class StramTest02 {public static void main(String[] args) {Employee employee01=new Employee("yang","hui",9);Employee employee02=new Employee("yang","hui",49);Employee employee03=new Employee("yang","hui",9);Employee employee04=new Employee("yang","hui",89);Employee employee05=new Employee("yang","hui",89);Employee employee06=new Employee("yang","hui",89);List<Employee> list= Arrays.asList(employee01,employee02,employee03,employee04,employee05,employee06);//创建StreamStream<Employee> stream1 = list.stream();//对stream1流进行过滤Stream<Employee> s = stream1.filter((e) -> {System.out.println("---------------filter------------");//过滤掉年龄小于19return e.getAge() >= 19;}).skip(2);//s=s.skip(5);s.forEach((e-> System.out.println(e)));}
}

运行截图：

distinct:筛选重复的元素，通过流生产元素的hashCode()和equals去除重复元素；

package com.ysh.review01_Stream;import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.stream.Stream;public class StramTest02 {public static void main(String[] args) {Employee employee01=new Employee("yang","hui",9);Employee employee02=new Employee("yang","hui",49);Employee employee03=new Employee("yang","hui",9);Employee employee04=new Employee("yang","hui",89);Employee employee05=new Employee("yang","hui",89);Employee employee06=new Employee("yang","hui",89);List<Employee> list= Arrays.asList(employee01,employee02,employee03,employee04,employee05,employee06);//创建StreamStream<Employee> stream1 = list.stream();//对stream1流进行过滤Stream<Employee> s = stream1.filter((e) -> {System.out.println("---------------filter------------");//过滤掉年龄小于19return e.getAge() >= 19;}).skip(2).distinct();//s=s.skip(5);s.forEach((e-> System.out.println(e)));}
}

运行截图：

排序：

sorted(Comparable)–自然排序

package com.ysh.review01_Stream;import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;public class StreamTest03 {public static void main(String[] args) {List<String> list= Arrays.asList("c","bbb","abc","bbbb");Stream<String> stream = list.stream();//即通过调用String方法中CompareTo，通过一个一个的比较字符的ASCLL值，首先比较首字符的ASCLL大小，相同的话再比较下一个stream= stream.sorted();stream.forEach(System.out::println);}
}

sorted(Comparator)–定制排序

package com.ysh.review01_Stream;import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.stream.Stream;public class StramTest02 {public static void main(String[] args) {Employee employee01=new Employee("yang","哈哈",19);Employee employee02=new Employee("yang","hui",49);Employee employee03=new Employee("yang","hui",79);Employee employee04=new Employee("yang","呵呵呵",79);Employee employee05=new Employee("yang","hui",39);Employee employee06=new Employee("yang","hui",29);List<Employee> list= Arrays.asList(employee01,employee02,employee03,employee04,employee05,employee06);//创建StreamStream<Employee> stream1 = list.stream();//对stream1流进行过滤Stream<Employee> s = stream1.filter((e) -> {System.out.println("---------------filter------------");//过滤掉年龄小于19return e.getAge() >= 19;});//s=s.skip(5);/*此处可以使用Lambda表达式，即s.sorted((o1,o2)->{//升序排序，如果年龄相同，则按照姓名的长度排序 if (o1.getAge()==o2.getAge()){return o1.getName().length()-o2.getName().length();}//按照年龄升序排序return o1.getAge()-o2.getAge();})*/s=s.sorted(new Comparator<Employee>() {@Overridepublic int compare(Employee o1, Employee o2) {//升序排序，如果年龄相同，则按照姓名的长度排序if (o1.getAge()==o2.getAge()){return o1.getName().length()-o2.getName().length();}//按照年龄升序排序return o1.getAge()-o2.getAge();}});s.forEach((e-> System.out.println(e)));}
}

Stream中的map和flatMap方法：

流中的每一个数据，当做map方法的参数(接口)，接口中抽象方法的参数，进行制定操作，最终得到一个结果，最后所有的结果返回去成为一个流
流中的每一个数据当作参数，进行操作，得到的结果必须是一个流，最终会结合成一个流返回

package com.ysh.review01_Stream;import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;public class StreamTest04 {public static void main(String[] args) {Stream<String> stream=Stream.of("aaa","bbbb","ccccc");//map方法是每一个数据当作一个流，即以上{aaa}、{bbbb}、{ccccc}各是一个Stream<Character>流集合，即达到得到多个Stream<Character>流集合//可以理解为Stream流中包含Stream<Character>流//因为这里的testCharacter()的方法我返回的是一个Stream<Character>//Stream<Stream<Character>> streamStream = stream.map((e) -> testCharacter(e));Stream<Stream<Character>> streamStream = stream.map((e) -> {List<Character> list = new ArrayList<>();for (Character c : e.toCharArray()) {list.add(c);}return list.stream();});streamStream.forEach((e)->{e.forEach((e2)->{System.out.println(e2);});});Stream<String> stm=Stream.of("aaa","bbbb","ccccc");//flatMap()方法即是把将得到的多个Stream<Character>流集合合并为一个一个Stream<Character>流集合Stream<Character> stream1=stm.flatMap(StreamTest04::testCharacter);//streamStream.forEach(System.out::println);System.out.println("---------------");stream1.forEach(System.out::println);}//返回一个Streampublic static Stream<Character> testCharacter(String str){List<Character> list=new ArrayList<>();for (Character c:str.toCharArray()){list.add(c);}Stream<Character> stream=list.stream();return stream;}
}

终止操作
查找与匹配

allMatch:检查是否匹配所有元素；
anyMatch:检查是否至少匹配一个元素；
noneMatch:检查是否没有匹配所有元素；
findFirst:返回第一个元素；
findAny:返回当前流中的任意元素；
count:返回流中元素的总个数；
max:返回流中最大值；
min:返回流中最小值；

代码实例：

package com.ysh.review01_Stream;import java.util.Optional;
import java.util.stream.Stream;/*** Stream中的终止操作*/
public class StreamTest06 {public static void main(String[] args) {//获取StreamStream<String> stm1=Stream.of("aaaaaa","bbbbb","cccccc","dd","eee");//allMatch()方法里面的参数是一个断言式接口，即实现必须重写test()方法boolean b1 = stm1.allMatch((t) -> {//检查是否匹配所有元素return t.length() > 2;});Stream<String> stm2=Stream.of("aaaaaa","bbbbb","cccccc","dd","eee");boolean b2=stm2.anyMatch((t) -> {//检查是否至少匹配一个元素return t.length() > 2;});Stream<String> stm3=Stream.of("aaaaaa","bbbbb","cccccc","dd","eee");boolean b3=stm3.noneMatch((t) -> {//检查是否没有匹配所有元素return t.length() > 2;});Stream<String> stm4=Stream.of("aaaaaa","bbbbb","cccccc","dd","eee");//得到流中的第一个元素Optional<String> first = stm4.findFirst();//输出System.out.println(first.get());Stream<String> stm5=Stream.of("aaaaaa","bbbbb","cccccc","dd","eee");//返回当前流中的任意元素Optional<String> any = stm5.findAny();System.out.println(any.get());Stream<String> stm6=Stream.of("aaaaaa","bbbbb","cccccc","dd","eee");//放回流中元素的总个数long count = stm6.count();System.out.println(count);Stream<String> stm7=Stream.of("aaaaaa","bbbbb","cccccc","dd","eee");//返回流中最大值，即长度最长，长度相同则比较ASCLL值大小Optional<String> max = stm7.max((s1, s2) -> {if (s1.length()==s2.length()){return s1.compareTo(s2);}return s1.length() - s2.length();});System.out.println(max.get());Stream<String> stm8=Stream.of("aaaaaa","bbbbb","cccccc","dd","eee");//返回流中最小值，即长度最短，长度相同则比较ASCLL值大小Optional<String> min = stm8.min((s1, s2) -> {if (s1.length() == s2.length()) {return s2.compareTo(s1);}return s1.length() - s2.length();});System.out.println(min.get());System.out.println(b3);}
}

收集：
收集-将流转换为其他形式，接收一个Collertor接口的实现，用于给Stream中元素做汇总的方法

List：把流中所有元素收集到List中，使用.collect(Collectors.toList());
Set：把流中所有元素收集到Set中，删除重复项，使用.collect(Collectors.toSet());
Map：把流中所有元素收集到Map中，当出现相同的key时会抛异常，使用 .collect(Collectors.toMap());
使用collect方法求流中共有几条数据，使用.collect(Collectors.counting())
使用collect方法求平均数，使用.collect(Collectors.averagingInt();
使用collect方法求某个变量的总和，使用.collect(Collectors.summingDouble());
使用collect方法且某个变量中值的最大值，使用.collect(Collectors.maxBy());

代码实例：

package com.ysh.review01_Stream.one;import java.util.*;
import java.util.stream.Collectors;public class StreamTest07 {public static void main(String[] args) {Student stu1=new Student("1","hhhh",18);Student stu2=new Student("2","hhhhh",19);Student stu3=new Student("3","oooooo",19);Student stu4=new Student("4","aaaaa",19);List<Student> list = Arrays.asList(stu1,stu2,stu3,stu4);//获取所有学生的姓名流，并且存储再List集合中List<String> collect = list.stream().map((e) -> {return e.getName();}).collect(Collectors.toList());System.out.println(collect);Set<String> set = list.stream().map((e) -> {return e.getName();}).collect(Collectors.toSet());System.out.println(collect);//将学生的姓名和年龄放入到一个集合中，当出现相同的key是会抛出一个java.lang.IllegalStateException: Duplicate key异常Map<String, Integer> map = list.stream().collect(Collectors.toMap((e) -> e.getName(), (e2) -> e2.getAge()));System.out.println(map);//运用collect输出所有学生的总数Long count2 = list.stream().collect(Collectors.counting());System.out.println(count2);//运用collect方法计算所有学生的平均年龄Double collect1 = list.stream().collect(Collectors.averagingDouble((n) -> n.getAge()));System.out.println(collect1);//运用collect方法求所有学生的年龄之和int agesum=list.stream().collect(Collectors.summingInt((e)->e.getAge()));System.out.println(agesum);//运用collect方法求所有学生中年龄最大的Optional<Student> max2 = list.stream().collect(Collectors.maxBy((a1, a2) -> a1.getAge() - a2.getAge()));System.out.println(max2.get());}
}
class Student {private String id;private String name;private int age;public Student(){}public Student(String id, String name, int age) {this.id = id;this.name = name;this.age = age;}public String getId() {return id;}public void setId(String id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;return age == student.age &&id.equals(student.id) &&name.equals(student.name);}@Overridepublic int hashCode() {return Objects.hash(id, name, age);}@Overridepublic String toString() {return "Employee{" +"id='" + id + ''' +", name='" + name + ''' +", age=" + age +'}';}
}

作者：前程有光
链接：https://juejin.im/post/6888549645908181005
来源：掘金

stream流_Stream流的这些操作，你得知道，对你工作有很大帮助相关推荐

网购时碰到这种卖家操作，一定要记得，否则损失很大
前几天帮朋友在天猫,买了块电视机付款1789,说是申请退运费,退回200元电视昨天送到的,试了下就签字了,晚上的时候就跟客服沟通了,朋友也只是给了我1589,我深思先把那200要回来吧. 客服跟我说 ...
Java变长数组笛卡尔积_Java 8中的流作为流的笛卡尔积（仅使用流）
小编典典在示例中传递流永远比传递列表更好: private static Stream cartesian(BinaryOperator aggregator, List... lists) { . ...
跟我学 Java 8 新特性之 Stream 流（三）缩减操作
转载自跟我学 Java 8 新特性之 Stream 流(三)缩减操作和前面两篇文章一起服用,效果会更佳.通过对流API的基础体验Demo和关键知识点的讲解,相信大家对流API都有一定的认识了, ...
java 1.8stream_java jdk1.8 使用stream流进行list 分组归类操作
我就废话不多说了,大家还是直接看代码吧~ import com.alibaba.fastjson.JSON; import java.util.ArrayList; import java.util. ...
二、使用Stream流的方式完成过滤操作
package stream01;import java.util.ArrayList; import java.util.stream.Stream;/*** 使用Stream流的方式完成过滤操作* ...
hashmap用stream流操作_基础篇：JAVA.Stream函数，优雅的数据流操作
前言平时操作集合数据,我们一般都是for或者iterator去遍历,不是很好看.java提供了Stream的概念,它可以让我们把集合数据当做一个个元素在处理,并且提供多线程模式流的创建流的各种数 ...
JAVA学习-Stream流的生成、中间操作、终结、收集操作
Stream流的使用-用于数据集的过滤.映射 1.生成流的操作:通过数据源.集合生成流list.stream() 2.中间操作:一个流可以跟随零个或多个中间操作,其目的主要是打开流,做出某种程度的数据 ...
Java8新特性——Stream流：不同于IO流的流，操作集合数据
文章目录 Stream流 1.认识Stream流(源码说明) 1.1.Stream流和Collection的区别 1.2.流的获取方式 1.3.流操作和管道 1.4.并行性 1.5.不干扰内政 1.6 ...
Java stream! Kafka steam!流式处理这么火！它究竟是个啥？
在这篇文章中,我将介绍Node.js和Java Streams以及Apache Kafka和Amazon Kinesis等工具,并简要概述每个工具,来说明啥是流处理! 数组是存储一系列值的数据结构.那 ...

stream流_Stream流的这些操作，你得知道，对你工作有很大帮助

Stream流

Stream流操作的三个步骤：

创建Stream步骤：

Stream的中间操作

筛选和切片

stream流_Stream流的这些操作，你得知道，对你工作有很大帮助相关推荐

最新文章

热门文章