set.stream使用 java_Java8之流Stream使用，附上例子-CSDN博客

本文链接：https://blog.csdn.net/weixin_36472718/article/details/114559585

packagestream;import java.util.*;importjava.util.concurrent.CopyOnWriteArrayList;importjava.util.stream.Collectors;importjava.util.stream.IntStream;importjava.util.stream.Stream;public classsteamMain {public static voidmain(String[] args) {/*** map函数

* 将流中的每⼀个元素 T 映射为 R(类似类型转换)

* 上堂课的例⼦就是，类似遍历集合，对集合的每个对象做处理

* 场景：转换对象，如javaweb开发中集合⾥⾯的DO对象转换为DTO对象*/List list = Arrays.asList("springboot教程", "微服务教程", "并发编程", "压⼒测试", "架构课程");

List li = Arrays.asList("asdad", "dfsfs", "erdsd", "zxcsdad", "weqqweqsd");

List resultlist = list.stream().map(obj -> "我想学习" +obj).collect(Collectors.toList());

System.out.println(resultlist);

List list1 = Arrays.asList(new user(12, "123"), new user(23, "234"), new user(24, "345"));

List resLIst = list1.stream().map(obj ->{

userDTO user= newuserDTO();

user.setName(obj.getName());returnuser;

}).collect(Collectors.toList());

System.out.println(resLIst);/*** filter 函数

* ⽤于通过设置的条件过滤出元素

* 需求：过滤出字符串⻓度⼤于5的字符串*/List list2 = list.stream().filter(obj -> obj.length() > 4).collect(Collectors.toList());

System.out.println(list2);/*** sorted 函数

* sorted() 对流进⾏⾃然排序, 其中的元素必须实现Comparable 接⼝*/

//默认升序//List list4 = li.stream().sorted(Comparator.comparing(String::length)).collect(Collectors.toList());//反转降序//List list4 = li.stream().sorted(Comparator.comparing(String::length).reversed()).collect(Collectors.toList());

List list4 =li.stream().sorted(Comparator.comparing(String::length, Comparator.reverseOrder())).collect(Collectors.toList());

System.out.println(list4);/*** limit函数

* 截断流使其最多只包含指定数量的元素*/List list5 = li.stream().limit(3).collect(Collectors.toList());

System.out.println(list5);/*** allMatch函数

* 检查是否匹配所有元素，只有全部符合才返回true*/

boolean status = li.stream().allMatch(obj -> obj.length() > 4);

System.out.println(status);/*** anyMatch函数

* 检查是否⾄少匹配⼀个元素只要又一个符合要求，返回true*/

boolean status1 = li.stream().anyMatch(obj -> obj.length() > 10);

System.out.println(status1);/*** max函数*/

//Optional list7 = list1.stream().max(Comparator.comparingInt(user::getAge));

Optional list7 = list1.stream().max((s1, s2) ->Integer.compare(s1.getAge(), s2.getAge()));

System.out.println(list7.get().getAge());/*** min函数*/

//Optional list8 =list1.stream().min(Comparator.comparingInt(user::getAge));

Optional list8 = list1.stream().min((s1, s2) ->Integer.compare(s1.getAge(), s2.getAge()));

System.out.println(list8.get().getAge());/*** 并行流 parallelStream

* 为什么会有这个并⾏流

* 集合做重复的操作，如果使⽤串⾏执⾏会相当耗时，因此⼀般会采⽤多线程来加快， Java8的

* paralleStream⽤fork/join框架提供了并发执⾏能⼒

* 底层原理

* 线程池(ForkJoinPool)维护⼀个线程队列

* 可以分割任务，将⽗任务拆分成⼦任务，完全贴合分治思想

* paralleStream并⾏是否⼀定⽐Stream串⾏快？

* 错误，数据量少的情况，可能串⾏更快，ForkJoin会耗性能

* 多数情况下并⾏⽐串⾏快，是否可以都⽤并⾏

* 不⾏，部分情况会有线程安全问题，parallelStream⾥⾯使⽤的外部变量，⽐如集合⼀

* 定要使⽤线程安全集合，不然就会引发多线程安全问题*/

//两种区别

System.out.println("Stream输出集合");

li.stream().forEach(System.out::println);

System.out.println("parallelStream");

li.parallelStream().forEach(System.out::println);//使用parallelStream有线程安全问题，所以集合对象需要集合安全的对象//循环10次

for (int i = 0; i < 10; i++) {//arrayList的添加方法没有加锁，线程不安全//List paralleList = new ArrayList();

List paralleList = newCopyOnWriteArrayList();//生成0到100的数，并行的加入到数组

IntStream.range(0, 100).parallel().forEach(paralleList::add);//如果是用的是ArrayList 这里会报数组下标越界异常，原因ArrayLits的add方法没有加锁，循环到了第9次时，因为是多线程，查看size的时候，都同时加1了，导致下标越界。//换成CopyOnWriteArrayList集合则不会，因为CopyOnWriteArrayList集合的add方法有加锁

System.out.println(paralleList.size());

}/*** reduce操作

* 什么是reduce操作

* 聚合操作，中⽂意思是 “减少”

* 根据⼀定的规则将Stream中的元素进⾏计算后返回⼀个唯⼀的值

* 常⽤⽅法⼀

Optional reduce(BinaryOperator accumulator);*/

//累加器

int value = Stream.of(1, 2, 3, 4, 5, 6).reduce((item1, item2) -> item1 +item2).get();

System.out.println(value);//带起始值的累加器

int value1 = Stream.of(1, 2, 3, 4, 5, 6).reduce(100, (item1, item2) -> item1 +item2);

System.out.println(value1);//使用reduce求出最大值

int value2 = Stream.of(213, 2312, 12, 454).reduce((item1, item2) -> item1 > item2 ?item1 : item2).get();

System.out.println(value2);/*** foreach操作

* 集合遍历的⽅式

* for循环

* 迭代器 Iterator

* Jdk8⾥⾯的新增接⼝

* default void forEach(Consumer super T> action) {

* Objects.requireNonNull(action);

* for (T t : this) {

* action.accept(t);

* }

* 注意点

* 不能修改包含外部的变量的值

* 不能⽤break或者return或者continue等关键词结束或者跳过循环*/list1.stream().forEach(obj->System.out.println(obj));int totalAge = 0;//测试修改包含外部的变量的值//list1.stream().forEach(obj ->{//System.out.println(obj);//totalAge += obj.getAge();//});//测试⽤break或者return或者continue等关键词结束或者跳过循环//li.stream().forEach(obj ->{//System.out.println(obj);//return;//});

/*** collector 收集器

* ⼀个终端操作, ⽤于对流中的数据进⾏归集操作，collect⽅法接受的参数是⼀个Collector

* 有两个重载⽅法，在Stream接⼝⾥⾯

* default void forEach(Consumer super T> action) {

* Objects.requireNonNull(action);

* for (T t : this) {

* action.accept(t);

* }

* List results = Arrays.asList(new Student(32),new

* Student(33),new Student(21),new Student(29),new Student(18));

* results.forEach(obj->{

* System.out.println(obj.toString());

* });

* Collector的作⽤

* 就是收集器，也是⼀个接⼝, 它的⼯具类Collectors提供了很多⼯⼚⽅法

* Collectors 的作⽤

* ⼯具类，提供了很多常⻅的收集器实现

* Collectors.toList()

* ArrayList::new，创建⼀个ArrayList作为累加器

* List::add，对流中元素的操作就是直接添加到累加器中

* reduce操作, 对⼦任务归集结果addAll，后⼀个⼦任务的结果直接全部添加到

* 前⼀个⼦任务结果中

* CH_ID 是⼀个unmodifiableSet集合

* Collectors.toMap()

* Collectors.toSet()

* Collectors.toCollection() ：⽤⾃定义的实现Collection的数据结构收集

* Collectors.toCollection(LinkedList::new)

* Collectors.toCollection(CopyOnWriteArrayList::new)

* Collectors.toCollection(TreeSet::new)*/List listStr = Stream.of("dsad", "dasdsa", "123dsa").collect(Collectors.toList());

System.out.println(listStr);//set集合

Set setStr = Stream.of("dsad", "dasdsa", "123dsa", "123dsa").collect(Collectors.toSet());

System.out.println(setStr);

Set setStr1 = Stream.of("dsad", "dasdsa", "123dsa", "123dsa").collect(Collectors.toCollection(TreeSet::new));

System.out.println(setStr1);

List listStr1 = Stream.of("dsad", "dasdsa", "123dsa", "123dsa").collect(Collectors.toCollection(ArrayList::new));

System.out.println(listStr1);/*** join函数

* 拼接函数 Collectors.joining

* //重载⽅法⼀

* R collect(Supplier supplier, BiConsumer

* accumulator, BiConsumercombiner);

* //重载⽅法⼆

* R collect(Collector super T, A, R> collector);

* public static Collector> toList() {

* return new CollectorImpl<>((Supplier>)

* ArrayList::new, List::add,(left, right) -> {

* left.addAll(right); return left; }, CH_ID);

* }

* 其中⼀个的实现

* 说明：

* 该⽅法可以将Stream得到⼀个字符串， joining函数接受三个参数，分别表示元素之间的连

* 接符、前缀和后缀。*/

//将数组集合"｜｜"拼接在一起

String value3 = list.stream().collect(Collectors.joining("||"));

System.out.println(value3);//还可以使用join函数，指定前缀和后缀

String value4 = list.stream().collect(Collectors.joining("||", "{", "}"));

System.out.println(value4);/*** partitioningBy分组

* Collectors.partitioningBy 分组，key是boolean类型

* public static

* Collector>> partitioningBy(Predicate super

* T> predicate) {

* return partitioningBy(predicate, toList());

* }*/

//将数组长度大于5的字符串分出来

Map> boMap = li.stream().collect(Collectors.partitioningBy(obj -> obj.length() > 5));

boMap.forEach((k,v)->{

System.out.println(k+"->"+v);

});/*** groupby 分组

* 分组 Collectors.groupingBy()

* public static Collector>> groupingBy(Function

* super T, ? extends K> classifier) { return groupingBy(classifier, toList());

* }*/

//练习：根据学⽣所在的省份，进⾏分组

List studentList = Arrays.asList(new Student("⼴东", 23), newStudent("⼴东", 24), new Student("⼴东", 23),new Student("北京", 22), newStudent("北京", 20), new Student("北京", 20),new Student("海南", 25));

Map> stuMap = studentList.stream().collect(Collectors.groupingBy(obj ->obj.getProvince()));

stuMap.forEach((k,v)->{

System.out.println(k+"有"+v);

});//算出每个地区有多少人

/*** 分组统计，groupby分组进阶

* 分组后进行统计Collectors.counting() 统计元素个数*/Map longMap = studentList.stream().collect(Collectors.groupingBy(obj ->obj.getProvince(),Collectors.counting()));

longMap.forEach((k,v)->{

System.out.println(k+"有"+v+"人");

});/*** groupby分组进阶

* summarizing集合统计

* 作⽤：可以⼀个⽅法把统计相关的基本上都完成

* 分类

* summarizingInt

* summarizingLong

* summarizingDouble*/IntSummaryStatistics summaryStatistics= studentList.stream().collect(Collectors.summarizingInt(obj ->obj.getAge()));

System.out.println("平均年龄"+summaryStatistics.getAverage());

System.out.println("总人数"+summaryStatistics.getCount());

System.out.println("最大年龄"+summaryStatistics.getMax());