一键搭建网站windows,网站使用培训方案,电商网站建设实训报告,怎样进入wordpress仪表盘引言
Java8 加入了java.util.stream包#xff0c;这个包中的相关API将极大的增强容器对象对元素的操作能力。
它专注于对集合对象进行各种便利、高效的聚合操作#xff0c;或大批量数据处理。
Stream API借助于同样新出现的Lambda表达式#xff0c;极大的提高了编程效率和…引言
Java8 加入了java.util.stream包这个包中的相关API将极大的增强容器对象对元素的操作能力。
它专注于对集合对象进行各种便利、高效的聚合操作或大批量数据处理。
Stream API借助于同样新出现的Lambda表达式极大的提高了编程效率和程序信噪比。
它提供了串行和并行两种模式进行汇聚操作。并行模式底层采用 Fork / Join 框架来拆分任务和加速处理过程。
什么是流
一、流的概念
1、流不是数据结构
它没有内部存储它只是用操作管道从source数据结构、数组、IO channel抓取数据。
2、不修改源数据
例如Stream 的 filter操作会产生一个不包含被过滤元素的新的Stream而不是从source中删除那些元素。
3、流的操作参数
所有的Stream操作必须以Lambda表达式作为参数。
4、不支持索引访问
Stream操作实际上是 增强For循环 的函数编程变式它没有元素下标的访问方式。
5、流可以转换成数组或者List
6、惰性化
Intermediate操作永远是惰性化的
7、并行能力
当一个集合不要求元素的顺序时我们可以通过Stream的并行化特性来充分利用多核资源不需要再写多线程代码所有对它的操作会自动并行进行。
8、可以是无限的
集合有固定大小Stream则不必limit(n)、findFirst()这类short-circuiting操作可以对无限的Stream进行运算并很快完成。
二、流的操作分类
流的操作类型被分为三种Intermediate、Terminal、short-circuiting 。
Intermediate 代表流的中间操作这种操作的目的主要是打开流做出某种程度的映射或过滤然后返回一个新的流交给下一个操作使用。这类操作是惰性的也就是说仅仅调用到这类方法并没有真正开始流的遍历。
Terminal 一个流只能有一个Terminal操作。所以这必定是流的最后一个操作。而Terminal操作的执行才会真正开始流的遍历并且会生成一个结果或者一个副作用。
short-circuiting 对于Intermediate 操作如果接收的是一个无限大的Stream则返回一个有限的新Stream对于Terminal 操作如果它接收的是一个无限大的Stream但能在有限的时间计算出结果。
三、惰性化lazy
我们说Intermediate操作都是惰性化的这如何理解在对于一个Stream进行多次转换操作Intermediate操作每次操作都对Stream中的每个元素进行转换而且是执行多次这样时间复杂度就是 N转换次数个for循环里所有操作都执行完的总和吗其实不是这样的
我们说转换操作是Lazy的多个转换操作只会在Terminal 操作的时候融合进来一次循环完成。
我们可以这样简单的类比在Java 8 未引进Stream API的时候使用命令式进行for循环并对每个元素进行诸如 if-else 、赋值、计算、获取、添加等操作而这些操作你可以理解为Stream中的Intermediate操作只有在for循环真正执行的时候才会执行它们这就是惰性化的语义即提前安排好筛选、计算等Intermediate操作当循环时再执行它们。
常见用法归纳
一、创建流
我们可以通过一个“集合”对象来创建流这个集合对象并不限于Collection接口还包含那些能容纳多个对象的容器。
创建流的方式大致可以分为三种Arrays.stream()、Stream.of()、集合.stream()下面举例来说明
1、数组生成流
// 基本类型数组
int[] numx new int[] { 1, 2, 2, 3, 5 };
// 方法一
IntStream stream1 Arrays.stream(numx);// 方法二
IntStream stream2 IntStream.of(numx);// 引用类型数组
Integer[] nums new Integer[] { 1, 2, 2, 3, 5 };// 方法一
StreamInteger stream3 Arrays.stream(nums);// 方法二
StreamInteger stream4 Stream.of(nums);需要注意的是对于基本数值型目前有三种对应的包装类型 Stream
IntStream、LongStream、DoubleStream。当然我们也可以用 StreamInteger、StreamLong 、StreamDouble但是 boxing 和 unboxing 会很耗时所以特别为这三种基本数值型提供了对应的 Stream。 Java 8 中还没有提供其它数值型 Stream因为这将导致扩增的内容较多。而常规的数值型聚合运算可以通过上面三种 Stream 进行。 2、集合生成流
ListInteger numsList Arrays.asList( 1, 2, 2, 3, 5 );
// 使用parallelStream会将List进行分段并行处理因此处理的顺序是不固定的。
StreamInteger parallelStream numsList.parallelStream();
二、流转化为容器(Terminal)
StreamString names Arrays.asList(Tom, Jerry, Tim, Morty).stream();
1、Stream转Array
String[] namesArr names.toArray(String[]::new);
2、 Stream转Collection
ListString list1 names.collect(Collectors.toList());
// 或
ListString list2 names.collect(Collectors.toCollection(ArrayList::new));
SetString set names.collect(Collectors.toSet());
StackString stack names.collect(Collectors.toCollection(Stack::new));
3、Stream转String
String str names.collect(Collectors.joining());// joining()有重载 三、映射操作Intermediate
map将input stream中的每一个元素映射成output stream中的另外一个元素(一对一映射)
ListString output names.map(String::toUpperCase).collect(Collectors.toList());
四、多集合映射操作Intermediate
flatMap功能和map相同只不过映射是一对多flatMap 把 input Stream 中的层级结构扁平化就是将最底层元素抽出来放到一起。
ListString names1 Arrays.asList(Tom, Jerry, Tim, Morty);
ListString names2 Arrays.asList(Tony, Jack, Tina, Marry);
ListString collect Stream.of(names1, names2).flatMap(ns - ns.stream().map(String::toLowerCase)).collect(Collectors.toList());
五、筛选操作Intermediate
filter对原始 Stream 进行某项测试符合条件表达式的元素被留下来生成一个新 Stream 或集合。
Integer[] sixNums { 1, 2, 3, 4, 5, 6 };
Integer[] evens Stream.of(sixNums).filter(n - n % 2 0).toArray(Integer[]::new);
六、循环操作Terminal
forEach() 方法接收一个 Lambda 表达式然后在 Stream 的每一个元素上执行该表达式。
但一般认为forEach 和常规 for 循环的差异不涉及到性能它们仅仅是函数式风格与传统 Java 风格的差别.
注意:forEach 不能修改自己包含的本地变量值也不能用 break/return 之类的关键字提前结束循环。
当需要为多核系统优化时可以 parallelStream().forEach()。另外一点需要注意forEach 是 terminal 操作。具有相似功能的 intermediate 操作 peek 可以达到上述目的。
Stream.of(one, two, three, four).filter(e - e.length() 3).peek(e - System.out.println(Filtered value: e)).map(String::toUpperCase).peek(e - System.out.println(Mapped value: e)).collect(Collectors.toList());
七、第一个元素Terminal
findFirst是一个 termimal 兼 short-circuiting 操作它总是返回 Stream 的第一个元素或者空。
注意它的返回值类型Optional。使用Optional的目的是尽可能避免 NullPointerException。它提供的是编译时检查能极大的降低 NPE 这种 Runtime Exception 对程序的影响。
OptionalString firstName names2.stream().findFirst();
八、聚合操作Terminal
reduce方法的主要作用是把 Stream 元素组合起来。它提供一个起始值种子然后依照运算规则BinaryOperator和前面 Stream 的第一个、第二个、第 n 个元素组合。从这个意义上说字符串拼接、数值的 sum、min、max、average 都是特殊的 reduce。
下面代码例如第一个示例的 reduce()第一个参数空白字符即为起始值第二个参数String::concat为 BinaryOperator。这类有起始值的 reduce() 都返回具体的对象。而对于第四个示例没有起始值的 reduce()由于可能没有足够的元素返回的是 Optional请留意这个区别。
// 字符串连接concat ABCD
String concat Stream.of(A, B, C, D).reduce(, String::concat);
// 求最小值minValue -3.0
double minValue Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min);
// 求和sumValue 10, 有起始值
int sumValue Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);
// 求和sumValue 10, 无起始值
sumValue Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
// 过滤字符串连接concat ace
String s Stream.of(a, B, c, D, e, F).filter(x - x.compareTo(Z) 0).reduce(, String::concat);
九、limit/skip Short-circuiting
limit 返回 Stream 的前面 n 个元素skip 则是扔掉前 n 个元素它是由一个叫 subStream 的方法改名而来。
ListString persons new ArrayList();
for (int i 1; i 10000; i) {persons.add(new String(name i));
}
ListString personNameList persons.stream().map(String::toUpperCase).limit(10).skip(3).collect(Collectors.toList()); 上述代码是一个有 10000 个元素的 Stream但在 short-circuiting 操作 limit 和 skip 的作用下管道中 map 操作指定的toUpperCase()方法的执行次数为 limit 所限定的 10 次而最终返回结果再跳过前 3 个元素后只有后面 7 个返回。
执行结果 注意有一种情况 limit/skip 无法达到 short-circuiting 目的就是把它们放在 Stream 的排序操作后原因跟 sorted这个 intermediate 操作有关此时系统并不知道 Stream 排序后的次序如何所以 sorted 中的操作看上去就像完全没有被 limit 或者 skip 一样。
经典案例内存全量数据实现分页返回
如下代码所示page 从 1 开始分别翻页查询可以得到完美的分页输出结果。
其中skip代表一个偏移量limit代表输出限制由此方式达到了 SQL 语句中 limit x, y 的效果。
public class TestMemoryPage {public static final ListString totalNameList new ArrayList();static {for (int i 1; i 100; i) {totalNameList.add(name i);}}public static void main(String[] args) {// 可自由调整分页大小int pageSize 9;int total totalNameList.size();int totalPage (total pageSize - 1) / pageSize;System.out.println(totalNameList);System.out.println(pageSize pageSize, total total, totalPage totalPage);// 分页开始for (int page 1; page totalPage; page) {ListString pageList totalNameList.stream().skip((page - 1) * pageSize).limit(pageSize).collect(Collectors.toList());System.out.println(第page页数量pageList.size() 数据 pageList);}}
}
十、排序操作Intermediate
对 Stream 的排序通过 sorted 进行它比数组的排序更强之处在于你可以首先对 Stream 进行各类 map、filter、limit、skip 甚至 distinct 来减少元素数量后再排序这能帮助程序明显缩短执行时间。
ListString pList persons.stream().limit(2).sorted((p1, p2) - p1.toString().compareTo(p2.toString())).collect(Collectors.toList()); 十一、最大/最小值、去重操作Intermediate
min 和 max 的功能也可以通过对 Stream 元素先排序再 findFirst 来实现但前者的性能会更好为 O(n)而 sorted 的成本是 O(n log n)。同时它们作为特殊的 reduce 方法被独立出来也是因为求最大最小值是很常见的操作。
BufferedReader br new BufferedReader(new FileReader(c:\\noThisFile.txt));
int longest br.lines().mapToInt(String::length).max().getAsInt();br.close();
System.out.println(longest);
十二、匹配操作Terminal
Stream 有三个 match 方法从语义上说
allMatchStream 中全部元素符合传入的 predicate返回 true
anyMatchStream中只要有一个元素符合传入的 predicate返回 true
noneMatchStream 中没有一个元素符合传入的predicate返回 true
它们都不是要遍历全部元素才能返回结果。例如 allMatch 只要一个元素不满足条件就 skip 剩下的所有元素返回 false。
ListPerson persons new ArrayList();
persons.add(new Person(1, name 1, 10));
persons.add(new Person(2, name 2, 21));
persons.add(new Person(3, name 3, 34));
persons.add(new Person(4, name 4, 6));
persons.add(new Person(5, name 5, 55));
boolean isAllAdult persons.stream().allMatch(p - p.getAge() 18);
System.out.println(All are adult? isAllAdult);
boolean isThereAnyChild persons.stream().anyMatch(p - p.getAge() 12);
System.out.println(Any child? isThereAnyChild);
十三、常用聚合函数案例
数据准备声明一个User对象然后初始化一个user 列表
Data
AllArgsConstructor
public static class User implements Jsonable {private Long id;private String name;private Integer age;private String address;private String group;Overridepublic String toString() {return this.toJsonStr();}
}public static final ListUser users new ArrayList();static {User morty new User(1L, morty, 28, 昌平区天通中苑, 研发组);User tom new User(2L, tom, 24, 朝阳区将台街道, 研发组);User lucy new User(3L, lucy, 22, 朝阳区美景东方小区, 测试组);users.add(morty);users.add(tom);users.add(lucy);
}
13.1 提取某一列
ListString names users.stream().map(User::getName).collect(Collectors.toList());
System.out.println(names names);// names [morty, tom, lucy]
13.2 连接某一列
String joiningNames users.stream().map(User::getName).collect(Collectors.joining(_));
System.out.println(joiningNames joiningNames);// joiningNames morty_tom_lucy
13.3 映射表
MapLong, User userMapping users.stream().collect(Collectors.toMap(User::getId, o - o));
System.out.println(userMapping userMapping);// userMapping {1{address:昌平区天通中苑,name:morty,id:1,age:28,group:研发组}, 2{address:朝阳区将台街道,name:tom,id:2,age:24,group:研发组}, 3{address:朝阳区美景东方小区,name:lucy,id:3,age:22,group:测试组}}
13.4 按某列分组
MapString, ListUser userGroups users.stream().collect(Collectors.groupingBy(User::getGroup));
System.out.println(userGroups userGroups);// userGroups {测试组[{address:朝阳区美景东方小区,name:lucy,id:3,age:22,group:测试组}], 研发组[{address:昌平区天通中苑,name:morty,id:1,age:28,group:研发组}, {address:朝阳区将台街道,name:tom,id:2,age:24,group:研发组}]} 鸣谢
《Java 8 中的 Streams API 详解》
