一. 流的常用创建方法1-1 使用collection下的 stream() 和 parallelstream() 方法list<string> list = new arraylist<>();stream<string> stream = list.stream(); //获取一个顺序流stream<string> parallelstream = list.parallelstream(); //获取一个并行流
1-2 使用arrays 中的 stream() 方法，将数组转成流integer[] nums = new integer[10];stream<integer> stream = arrays.stream(nums);
1-3 使用stream中的静态方法：of()、iterate()、generate()// 1. of()stream<integer> stream = stream.of(1,2,3,4,5,6);// 2. iterate()stream<integer> stream2 = stream.iterate(0, (x) -> x + 2).limit(6);stream2.foreach(system.out::println); // 0 2 4 6 8 10// 3. generate()stream<double> stream3 = stream.generate(math::random).limit(2);stream3.foreach(system.out::println);
1-4 使用 bufferedreader.lines() 方法，将每行内容转成流bufferedreader reader = new bufferedreader(new filereader("f:\\test_stream.txt"));stream<string> linestream = reader.lines();linestream.foreach(system.out::println);
1-5 使用 pattern.splitasstream() 方法，将字符串分隔成流pattern pattern = pattern.compile(",");stream<string> stringstream = pattern.splitasstream("a,b,c,d");stringstream.foreach(system.out::println);
二、流的中间操作// 1. 筛选与切片filter：过滤流中的某些元素limit skip distinct sorted 都是有状态操作，这些操作只有拿到前面处理后的所有元素之后才能继续下去。limit(n)：获取前n个元素skip(n)：跳过前n元素，配合limit(n)可实现分页distinct：通过流中元素的 hashcode() 和 equals() 去除重复元素// 2. 映射map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。flatmap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。// 3. 消费 peek , 类似map， // map接收的是一个function表达式，有返回值；// 而peek接收的是consumer表达式，没有返回值。// 4. 排序sorted()：自然排序，流中元素需实现comparable接口sorted(comparator com)：定制排序，自定义comparator排序器// 5.
2-1 筛选、去重与切片：filter、distinct、skip、limit// 实例：集合内元素>5,去重，跳过前两位，取剩下元素的两个返回为新集合stream<integer> stream = stream.of(6, 4, 6, 7, 3, 9, 8, 10, 12, 14, 14);stream<integer> newstream = stream.filter(s -> s > 5) //6 6 7 9 8 10 12 14 14 .distinct() //6 7 9 8 10 12 14 .skip(2) //9 8 10 12 14 .limit(2); //9 8newstream.foreach(system.out::println);
2-2 映射：map、flatmap// 1. map可以看成一个转换器，传入一个对象，返回新的对象// map的使用实例 stream.map(x->x.getid());list<string> list = arrays.aslist("a,b,c", "1,2,3");// 去掉字符串中所有的,list<string> collect = list.stream().map(s -> s.replaceall(",", "")).collect(collectors.tolist());// collect集合内容为：{abc,123}system.out.println(collect);// 2. flatmap 效果：结果展平 ，即把嵌套集合，按照子集合的形式，统一放入到新的一个集合中 // 接收一个函数作为参数，将流中的每个值都换成另一个流，// 然后把所有流连接成一个流。stream<string> stringstream = list.stream().flatmap(s -> { // 将字符串以,分割后得到一个字符串数组 string[] split = s.split(","); // 然后将每个字符串数组对应流返回，flatmap会自动把返回的所有流连接成一个流 stream<string> stream = arrays.stream(split); return stream;});// stringstream.collect(collectors.tolist())的集合内容为：{a,b,c,1,2,3}system.out.println(stringstream.collect(collectors.tolist()));
2-3 归约：统计-计算-逻辑处理：reduce// 说明：reduce看似效果和map相似，// 但reduce返回的是函数经过执行运算后的结果,// 而map返回的是处理后新的集合list<string> membernames = new arraylist<>();membernames.add("amitabh");membernames.add("shekhar");membernames.add("aman");membernames.add("rahul");membernames.add("shahrukh");membernames.add("salman");membernames.add("yana");membernames.add("lokesh");// 将集合中的元素按照#连接成字符串，并返回放置在optional<string>中optional<string> reduced = membernames.stream() .reduce((s1,s2) -> s1 + "#" + s2);// 有值则取出打印显示 reduced.ifpresent(system.out::println); // 输出内容： amitabh#shekhar#aman#rahul#shahrukh#salman#yana#lokesh// 计算统计实例： /** * t reduce(t identity, binaryoperator<t> accumulator); * identity：它允许用户提供一个循环计算的初始值。 * accumulator：计算的累加器， */ private static void testreduce() { //t reduce(t identity, binaryoperator<t> accumulator); system.out.println("给定个初始值，求和"); system.out.println(stream.of(1, 2, 3, 4).reduce(100, (sum, item) -> sum + item)); system.out.println(stream.of(1, 2, 3, 4).reduce(100, integer::sum)); // 输出：110 system.out.println("给定个初始值，求min"); system.out.println(stream.of(1, 2, 3, 4).reduce(100, (min, item) -> math.min(min, item))); system.out.println(stream.of(1, 2, 3, 4).reduce(100, integer::min)); // 输出：1 system.out.println("给定个初始值，求max"); system.out.println(stream.of(1, 2, 3, 4).reduce(100, (max, item) -> math.max(max, item))); system.out.println(stream.of(1, 2, 3, 4).reduce(100, integer::max)); // 输出：100 //optional<t> reduce(binaryoperator<t> accumulator); // 注意返回值，上面的返回是t,泛型，传进去啥类型，返回就是啥类型。 // 下面的返回的则是optional类型 system.out.println("无初始值，求和"); system.out.println(stream.of(1, 2, 3, 4).reduce(integer::sum).orelse(0)); // 输出：10 integer sum=stream.of(1, 2, 3, 4).reduce((x,y)->x+y).get(); system.out.println(sum); // 输出：10 system.out.println("无初始值，求max"); system.out.println(stream.of(1, 2, 3, 4).reduce(integer::max).orelse(0)); // 输出：4 system.out.println("无初始值，求min"); system.out.println(stream.of(1, 2, 3, 4).reduce(integer::min).orelse(0)); // 输出：1 }
2-4 排序：sorted// 按照默认字典顺序排序stream.sorted(); // 按照sortno排序stream.sorted((x,y)->integer.compare(x.getsortno(),y.getsortno())); 2-4-1 函数式接口排序// 正向排序（默认）pendingperiod.stream().sorted(comparator.comparingint(reservoirperiodresult::getid));// 逆向排序pendingperiod.stream().sorted(comparator.comparingint(reservoirperiodresult::getid).reversed()); 2-4-2 localdate 和 localdatetime 排序// 准备测试数据stream<datemodel> stream = stream.of(new datemodel(localdate.of(2020, 1, 1)), new datemodel(localdate.of(2021, 1, 1)), new datemodel(localdate.of(2022, 1, 1)));// 正向排序（默认）stream.sorted(comparator.comparing(datemodel::getlocaldate)).foreach(system.out::println);// 逆向排序stream.sorted(comparator.comparing(datemodel::getlocaldate).reversed()).foreach(system.out::println);
三. 流的终止操作 allmatch,nonematch,anymatch,findfirst,findany,count,max,min// 匹配和聚合allmatch，nonematch，anymatch用于对集合中对象的某一个属性值是否存在判断。 allmatch全部符合该条件返回true， nonematch全部不符合该断言返回true anymatch 任意一个元素符合该断言返回true// 实例：list<integer> list = arrays.aslist(1, 2, 3, 4, 5);boolean allmatch = list.stream().allmatch(e -> e > 10); //falseboolean nonematch = list.stream().nonematch(e -> e > 10); //trueboolean anymatch = list.stream().anymatch(e -> e > 4); //true// 其他一些方法findfirst：返回流中第一个元素 string firstmatchedname = membernames.stream() .filter((s) -> s.startswith("l")) .findfirst().get();findany：返回流中的任意元素count：返回流中元素的总个数 long totalmatched = membernames.stream() .filter((s) -> s.startswith("a")) .count();max：返回流中元素最大值min：返回流中元素最小值
3-1 普通收集 – 收集为list// 默认返回的类型为arraylist，可通过collectors.tocollection(linkedlist::new)// 显示指明使用其它数据结构作为返回值容器。list<string> collect = stream.collect(collectors.tolist());// 由集合创建流的收集需注意：仅仅修改流字段中的内容，没有返回新类型，// 如下操作直接修改原始集合，无需处理返回值。uservos.stream().map(e -> e.setdeptname(hashmap.get(e.getdeptid()))).collect(collectors.tolist());// 收集偶数集合的实例：list<integer> list = new arraylist<integer>();for(int i = 1; i< 10; i++){ list.add(i);}stream<integer> stream = list.stream();list<integer> evennumberslist = stream.filter(i -> i%2 == 0) .collect(collectors.tolist());system.out.print(evennumberslist);
3-2 普通收集 – 收集流为数组(array)// list 为 {1,2,3,.....100}stream<integer> stream = list.stream();integer[] evennumbersarr = stream.filter(i -> i%2 == 0).toarray(integer[]::new);
3-3 普通收集 – 收集为set// 默认返回类型为hashset，可通过collectors.tocollection(treeset::new)// 显示指明使用其它数据结构作为返回值容器。set<string> collect = stream.collect(collectors.toset());
3-4 高级收集 – 收集为map// 默认返回类型为hashmap，可通过collectors.tocollection(linkedhashmap::new)// 显示指明使用其它数据结构作为返回值容器// 测试实体类@datapublic class entity { private integer id; private string name;}// 模拟从数据库中查询批量的数据list<entity> entitylist = stream.of(new entity(1,"a"), new entity(2,"b"), new entity(3,"c")).collect(collectors.tolist());// 将集合数据转化成id与name的mapmap<integer, string> hashmap = entitylist.stream().collect(collectors.tomap(entity::getid, entity::getname));
3-5 高级收集 – 分组收集// 默认使用list作为分组后承载容器map<integer, list<xuser>> hashmap = xusers.stream().collect(collectors.groupingby(xuser::getdeptid)); // 显示指明使用list作为分组后承载容器map<integer, list<xuser>> hashmap = xusers.stream().collect(collectors.groupingby(xuser::getdeptid, collectors.tolist()));// 映射后再分组map<integer, list<string>> hashmap = xusers.stream().collect(collectors.groupingby(xuser::getdeptid,collectors.mapping(xuser::getusername,collectors.tolist())));
四. steam拓展4-1 集合与对象互转/** * 将单个对象转化为集合 * * @param t 对象实例 * @param <t> 对象类型 * @param <c> 集合类型 * @return 包含对象的集合实例 */public static <t, c extends collection<t>> collection<t> tocollection(t t) { return tocollection(t, arraylist::new);}/** * 用户自定义返回的集合实例类型: 将单个对象转化为集合 * * @param t 对象实例 * @param supplier 集合工厂 * @param <t> 对象类型 * @param <c> 集合类型 * @return 包含对象的集合实例 */public static <t, c extends collection<t>> collection<t> tocollection(t t, supplier<c> supplier) { return stream.of(t).collect(collectors.tocollection(supplier));}
4-2 集合转对象/** * 取出集合中第一个元素 * * @param collection 集合实例 * @param <e> 集合中元素类型 * @return 泛型类型 */public static <e> e toobject(collection<e> collection) { // 处理集合空指针异常 collection<e> coll = optional.ofnullable(collection).orelseget(arraylist::new); // 此处可以对流进行排序，然后取出第一个元素 return coll.stream().findfirst().orelse(null);}
4-3 java steam中的并发操作实例list<integer> list = new arraylist<integer>();for(int i = 1; i< 10; i++){ list.add(i);}stream<integer> stream = list.parallelstream(); // 创建并发流integer[] evennumbersarr = stream.filter(i -> i%2 == 0).toarray(integer[]::new);system.out.print(evennumbersarr); // 打印出的偶数为无规则排序的
以上就是java中steam流如何使用的详细内容。