一个公司怎么做网站都放些什么,嘉兴网站制作平台,超市建网站,aplkey怎么注册域名Java 8 Stream 流用法
1.简介
Stream流 最全的用法 Stream 能用来干什么#xff1f;用来处理集合#xff0c;通过 使用Stream API 对集合数据进行操作#xff0c;就类似于使用 SQL 执行的数据库查询#xff0c;Stream API 提供了一种高效且易于使用的处理数据的方式
为什…Java 8 Stream 流用法
1.简介
Stream流 最全的用法 Stream 能用来干什么用来处理集合通过 使用Stream API 对集合数据进行操作就类似于使用 SQL 执行的数据库查询Stream API 提供了一种高效且易于使用的处理数据的方式
为什么用Java 8 Stream 因为 操作简单 为什么操作简单?因为 Lambda 表达式它极大的提高了编程效率和程序可读性 怎么操作流 首先你的有个数据源(数组、集合)操作会产生新的流对象原来的流对象不会改变 流用法有结束操作这种代码不是你写了一个方法就执行一个方法而是最后触发结束操作的时候才统一执行的collect、foreach 方法就是一种结束方法详情看代码及结果参考 2.映射map、flatMap用法 部分 2.具体用法
2.1 创建流 // 集合创建流ListString list new ArrayList();// 获取一个顺序流StreamString listStream list.stream();// 获取一个并行流StreamString parallelListStream list.parallelStream();// 数组创建流Integer[] nums new Integer[] { 1, 2, 3, 4, 5 };StreamInteger arrStream Arrays.stream(nums);arrStream.forEach(System.out::println);// 1 2 3 4 5// 静态方法of创建流StreamInteger ofStream Stream.of(1, 2, 3, 4, 5);ofStream.forEach(System.out::println);// 1 2 3 4 5// 静态方法iterate 创建流StreamInteger iterateStream Stream.iterate(1, (x) - x 10).limit(4);iterateStream.forEach(System.out::println); // 1 11 21 31// 静态方法generate 创建流StreamDouble generateStream Stream.generate(Math::random).limit(2);generateStream.forEach(System.out::println);2.2 操作流
1.过滤
filter过滤流中的某些元素(可以做一些基本的判空、替换、判断逻辑操作)limit(n)获取n个元素结果获取几个元素skip(n)跳过n元素配合limit(n)可实现分页distinct通过流中元素的 hashCode() 和 equals() 去除重复元素 //filter 判空StreamInteger notNullStreamObj Stream.of(1, 2, null, 4, 5, 6, 7, null, 2);StreamInteger notNullStream notNullStreamObj.filter(i - (null ! i));notNullStream.forEach(System.out::println);//1 2 4 5 6 7 2//filter 逻辑判断StreamInteger logicStreamObj Stream.of(1, 2, null, 4, 5, 6, 7, null, 2);StreamInteger logicStream logicStreamObj.filter(i - (i ! null i 5));logicStream.forEach(System.out::println); // 6 7//filter 替换StreamString strStreamObj Stream.of(aa, ab, null, ac, bd, ee);StreamString strStream strStreamObj.filter(str - (null ! str str.contains(a)));strStream.forEach(System.out::println); // aa ab ac//skip 跳过StreamString skipStreamObj Stream.of(aa, ab, null, ac, bd, ee);StreamString skipStream skipStreamObj.skip(2);skipStream.forEach(System.out::println); // null ac bd ee//distinct 去重StreamString disStreamObj Stream.of(aa, ab, null, ac, aa, ab, null, ee);StreamString disStream disStreamObj.distinct();disStream.forEach(System.out::println); // aa ab null ac ee2.映射
map接收一个函数作为参数该函数会被应用到每个元素上映射成一个新的元素。flatMap接收一个函数作为参数将流中的每个值都换成另一个流然后把所有流连接成一个流。peek这个操作很骚类似map只不过map 是Func函数提供返回值而peer是取出元素Consumer表达式设值我个人觉得没啥区别呢官方文档提示该方法主要用于调试做一些消耗这个对象但不修改它的东西没啥事不要用
很想问一下 这俩map、flatMap 区别 细品你细品你细细品
map是将每个元素 映射成一个新元素除非你过滤了否则不会改变元素个数 flatMap是将原流中的每个值都变成另一个流然后把流合并串起来必须有返回值拼装成新的流 //map 把包含a的元素替换成| 注意注意 元素还是一个整体对每个元素StreamString mapStreamObj Stream.of(a,b,c, a,e,f, g,h,i);StreamString mapStream mapStreamObj.map(str - str.replaceAll(,, |));mapStream.forEach(System.out::println); // a|b|c a|e|f h|i|j//flatMap 可以把元素 切分后再按照新元素组成新的字符串StreamString flatMapStreamObj Stream.of(a,b,c, a,e,f, g,h,i);StreamString flatMapStream flatMapStreamObj.flatMap(str - {String[] arr str.split(,);StreamString result Arrays.stream(arr);return result;});flatMapStream.forEach(System.out::println); //a b c d e f g h iSystem.out.println(1);StreamString peekStreamObj Stream.of(a,b,c, a,e,f, g,h,i);StreamString peekStream peekStreamObj.peek(e - System.out.println(Filtered value: e)).map(String::toUpperCase).peek(e - System.out.println(Mapped value: e));System.out.println(2 peek代码结束但是日志没打印);SetString stringSet peekStream.collect(Collectors.toSet());System.out.println(3 collect结束操作代码日志打印);stringSet.forEach(System.out::println);map执行结果
//看下执行结果说明 collect才是结束操作代码结束但是并不是真正结束
1
2 peek代码结束但是日志没打印
Filtered value: a,b,c
Mapped value: A,B,C
Filtered value: a,e,f
Mapped value: A,E,F
Filtered value: g,h,i
Mapped value: G,H,I
3 collect结束操作代码日志打印
A,B,C
A,E,F
G,H,I3.排序
sorted()自然排序流中元素需实现Comparable接口sorted(Comparator com)定制排序自定义Comparator排序器
先构建一个User类 public static class User {private String name;private Integer age;public User(String name, Integer age) {this.name name;this.age age;}public String getName() {return name;}public void setName(String name) {this.name name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age age;}Overridepublic String toString() {return User{ name name \ , age age };}}然后 看下sort用法
//按字母排序StreamString sortStreamObj Stream.of(a,e,f, a,d,c, a,b,i);StreamString sortStream sortStreamObj.sorted();sortStream.forEach(System.out::println); //abi adc aefUser u1 new User(bb, 1);User u2 new User(aa, 2);User u3 new User(cc, 3);User u4 new User(aa, 4);SetUser userSet Sets.newHashSet(u1, u2, u3, u4);StreamUser userStream userSet.stream().sorted((obj1, obj2) - {if (obj1.getName().equals(obj2.getName())) {//name相等 按agereturn obj1.getAge() - obj2.getAge();}return obj1.getName().compareTo(obj2.getName());});userStream.forEach(System.out::println);// u2 u4 u1 u3sort 执行结果
a,b,i
a,d,c
a,e,f
User{nameaa, age2}
User{nameaa, age4}
User{namebb, age1}
User{namecc, age3}4.流匹配
allMatch接收一个 Predicate 函数当流中每个元素都符合该断言时才返回true否则返回falsenoneMatch接收一个 Predicate 函数当流中每个元素都不符合该断言时才返回true否则返回falseanyMatch接收一个 Predicate 函数只要流中有一个元素满足该断言则返回true否则返回falsefindFirst返回流中第一个元素findAny返回流中的任意元素count返回流中元素的总个数max返回流中元素最大值min返回流中元素最小值 ListInteger numLists Arrays.asList(3, 4, 5, 6, 10);// 全部匹配 - trueboolean allMatch1 numLists.stream().allMatch(e - e 2); //trueSystem.out.println(allMatch1 allMatch1);// 全部匹配 - trueboolean allMatch2 numLists.stream().allMatch(e - e 5); //falseSystem.out.println(allMatch2 allMatch2);// 全部都不符合 - trueboolean noneMatch numLists.stream().noneMatch(e - e 20); //trueSystem.out.println(noneMatch noneMatch);// 任一元素符合 - trueboolean anyMatch numLists.stream().anyMatch(e - e 4); //trueSystem.out.println(anyMatch anyMatch);//返回第一个Integer findFirst numLists.stream().findFirst().get(); //3System.out.println(findFirst findFirst);//返回任一个Integer findAny numLists.stream().findAny().get(); System.out.println(findAny findAny);//返回 countlong count numLists.stream().count(); //5System.out.println(count count);//返回maxInteger max numLists.stream().max(Integer::compareTo).get(); //10System.out.println(max max);//返回minInteger min numLists.stream().min(Integer::compareTo).get();//3System.out.println(min min);匹配执行结果
allMatch1true
allMatch2false
noneMatchtrue
anyMatchtrue
findFirst3
findAny3
count5
max10
min35.组合操作
Reduce 就是组合操作ReduceBinaryOperator accumulator 没有起始值按照运算规则进行运算操作 解释第一次执行时accumulator函数的第一个参数为流中的第一个元素第二个参数为流中元素的第二个元素按照函数进行操作 第二次执行时第一个参数为第一次函数执行操作的结果第二个参数为流中的第三个元素往下依次类推返回Optinal 通过get()方法获取结果ReduceT identity, BinaryOperator accumulator含有初始值第二个是第一个的变形跟第一个方法对比不同的是此次这个会接受一个identity参数用来指定Stream循环的初始值。如果Stream为空就直接返回该值特殊该方法不会返回 Optional
Optional sumResult Stream.of(1, 2, 3, 4).reduce((sum, item) - {System.out.println(sum : sum);sum item;System.out.println(item: item);System.out.println(sum : sum);System.out.println(-----——---);return sum;});System.out.println(sumResult: sumResult.get());Integer sumDefineResult Stream.of(1, 2, 3, 4).reduce(100, (sum, item) - {System.out.println(sum : sum);sum item;System.out.println(item: item);System.out.println(sum : sum);System.out.println(---——-----);return sum;});System.out.println(sumDefineResult: sumDefineResult);reduce 执行结果
//下面是执行结果
//查看执行结果
sum : 1
item: 2
sum : 3
-----——---
sum : 3
item: 3
sum : 6
-----——---
sum : 6
item: 4
sum : 10
-----——---
sumResult: 10
sum : 100
item: 1
sum : 101
---——-----
sum : 101
item: 2
sum : 103
---——-----
sum : 103
item: 3
sum : 106
---——-----
sum : 106
item: 4
sum : 110
---——-----
sumDefineResult: 110
6. 收集转换操作
这是个最最最最最基本的操作10个流操作 9个都会使用到当前操作
collect(Collectors.toList()) 转换Listcollect(Collectors.toSet()) 转换SetCollectors.toMap(key, value) 转换Map 如果key重复报错Collectors.joining() join进行拼接Collectors.groupingBy(key) 以Key为map的 key分组Collectors.partitioningBy(规则) 以规则分区 比如 5 map key为truefalse User s1 new User(aa, 1);User s2 new User(bb, 2);User s3 new User(cc, 3);User s4 new User(dd, 2);ListUser list Arrays.asList(s1, s2, s3, s4);//转换listListInteger ageList list.stream().map(User::getAge).collect(Collectors.toList()); // [1, 2, 3]System.out.println(ageList.toString());//转成setSetInteger ageSet list.stream().map(User::getAge).collect(Collectors.toSet()); // [1, 2, 3]System.out.println(ageSet);//转成map,注:key不能相同否则报错MapString, Integer userMap list.stream().collect(Collectors.toMap(User::getName, User::getAge)); // {cc10, bb20, aa10}System.out.println(userMap);//字符串分隔符连接String joinName list.stream().map(User::getName).collect(Collectors.joining(,, (, ))); // (aa,bb,cc)System.out.println(joinName);//分组MapInteger, ListUser ageMap list.stream().collect(Collectors.groupingBy(User::getAge));System.out.println(ageMap);//多重分组,先根据类型分再根据年龄分MapInteger, MapInteger, ListUser typeAgeMap list.stream().collect(Collectors.groupingBy(User::getAge, Collectors.groupingBy(User::getAge)));System.out.println(typeAgeMap);//分区//分成两部分true 一部分age大于2岁 false 一部分age小于等于2岁MapBoolean, ListUser partMap list.stream().collect(Collectors.partitioningBy(v - v.getAge() 2));System.out.println(partMap);collect 执行结果
[1, 2, 3, 2]
[1, 2, 3]
{dd2, cc3, bb2, aa1}
(aa,bb,cc,dd)
{1[User{nameaa, age1}], 2[User{namebb, age2}, User{namedd, age2}], 3[User{namecc, age3}]}
{1{1[User{nameaa, age1}]}, 2{2[User{namebb, age2}, User{namedd, age2}]}, 3{3[User{namecc, age3}]}}
{false[User{nameaa, age1}, User{namebb, age2}, User{namedd, age2}], true[User{namecc, age3}]}
