package stream;
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class steamMain {
public static void main(String[] args) {
/**
* map函数
* 将流中的每⼀个元素 T 映射为 R（类似类型转换）
* 上堂课的例⼦就是，类似遍历集合，对集合的每个对象做处理
* 场景：转换对象，如javaweb开发中集合⾥⾯的DO对象转换为DTO对象
*/
List<String> list = Arrays.asList("springboot教程", "微服务教程", "并发编程", "压⼒测试", "架构课程");
List<String> li = Arrays.asList("asdad", "dfsfs", "erdsd", "zxcsdad", "weqqweqsd");
List<String> resultlist = list.stream().map(obj -> "我想学习" + obj).collect(Collectors.toList());
System.out.println(resultlist);
List<user> list1 = Arrays.asList(new user(12, "123"), new user(23, "234"), new user(24, "345"));
List<userDTO> resLIst = list1.stream().map(obj -> {
userDTO user = new userDTO();
user.setName(obj.getName());
return user;
}).collect(Collectors.toList());
System.out.println(resLIst);
/**
* filter 函数
* ⽤于通过设置的条件过滤出元素
* 需求：过滤出字符串⻓度⼤于5的字符串
*/
List<String> list2 = list.stream().filter(obj -> obj.length() > 4).collect(Collectors.toList());
System.out.println(list2);
/**
* sorted 函数
* sorted() 对流进⾏⾃然排序, 其中的元素必须实现Comparable 接⼝
*/
//默认升序
//List<String> list4 = li.stream().sorted(Comparator.comparing(String::length)).collect(Collectors.toList());
//反转 降序
//List<String> list4 = li.stream().sorted(Comparator.comparing(String::length).reversed()).collect(Collectors.toList());
List<String> list4 = li.stream().sorted(Comparator.comparing(String::length, Comparator.reverseOrder())).collect(Collectors.toList());
System.out.println(list4);
/**
* limit函数
* 截断流使其最多只包含指定数量的元素
*/
List<String> 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<user> list7 = list1.stream().max(Comparator.comparingInt(user::getAge));
Optional<user> list7 = list1.stream().max((s1, s2) -> Integer.compare(s1.getAge(), s2.getAge()));
System.out.println(list7.get().getAge());
/**
* min函数
*/
//Optional<user> list8 =list1.stream().min(Comparator.comparingInt(user::getAge));
Optional<user> 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 = new CopyOnWriteArrayList();
//生成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<T> reduce(BinaryOperator<T> 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<Student> 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<String> listStr = Stream.of("dsad", "dasdsa", "123dsa").collect(Collectors.toList());
System.out.println(listStr);
//set集合
Set<String> setStr = Stream.of("dsad", "dasdsa", "123dsa", "123dsa").collect(Collectors.toSet());
System.out.println(setStr);
Set<String> setStr1 = Stream.of("dsad", "dasdsa", "123dsa", "123dsa").collect(Collectors.toCollection(TreeSet::new));
System.out.println(setStr1);
List<String> listStr1 = Stream.of("dsad", "dasdsa", "123dsa", "123dsa").collect(Collectors.toCollection(ArrayList::new));
System.out.println(listStr1);
/**
* join函数
* 拼接函数 Collectors.joining
* //重载⽅法⼀
* <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T>
* accumulator, BiConsumer<R, R>combiner);
* //重载⽅法⼆
* <R, A> R collect(Collector<? super T, A, R> collector);
* public static <T> Collector<T, ?, List<T>> toList() {
* return new CollectorImpl<>((Supplier<List<T>>)
* 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 <T>
* Collector<T, ?, Map<Boolean, List<T>>> partitioningBy(Predicate<? super
* T> predicate) {
* return partitioningBy(predicate, toList());
* }
*/
//将数组长度大于5的字符串分出来
Map<Boolean,List<String>> boMap = li.stream().collect(Collectors.partitioningBy(obj -> obj.length() > 5));
boMap.forEach((k,v) ->{
System.out.println(k+"->"+v);
});
/**
* groupby 分组
* 分组 Collectors.groupingBy()
* public static <T, K> Collector<T, ?, Map<K, List<T>>> groupingBy(Function<?
* super T, ? extends K> classifier) { return groupingBy(classifier, toList());
* }
*/
//练习：根据学⽣所在的省份，进⾏分组
List<Student> studentList = Arrays.asList(new Student("⼴东", 23), new
Student("⼴东", 24), new Student("⼴东", 23),new Student("北京", 22), new
Student("北京", 20), new Student("北京", 20),new Student("海南", 25));
Map<String,List<Student>> stuMap = studentList.stream().collect(Collectors.groupingBy(obj -> obj.getProvince()));
stuMap.forEach((k,v)->{
System.out.println(k+"有"+v);
});
//算出每个地区有多少人
/**
* 分组统计，groupby分组进阶
* 分组后进行统计Collectors.counting() 统计元素个数
*/
Map<String,Long> 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());
System.out.println("最小年龄"+summaryStatistics.getMin());
}
}
package stream;
public class Student {
private String province;
private int age;
public Student() {
}
public Student(String province, int age) {
this.province = province;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"province='" + province + '\'' +
", age=" + age +
'}';
}
public String getProvince() {
return province;
}
public void setProvince(String province) {
this.province = province;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package stream;
public class user {
private int age;
private String name;
public user(int age, String name) {
this.age = age;
this.name = name;
}
public user() {
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "user{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}
package stream;
public class userDTO {
private String name;
public userDTO(String name) {
this.name = name;
}
public userDTO() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
浙公网安备 33010602011771号