stream
lambda表达式是stream的基础,初学者建议先学习lambda表达式,http://www.cnblogs.com/andywithu/p/7357069.html
1. 作用
就是为了处理一些 集合数据(List, Map)和数组 Array更方便, 就像js中 forEach, filter filterIndex, map, sort, reduce...等
2. 流的特性
- 不改变数据
- 不改变原数据
- 延迟执行, 目的中间可以写异步逻辑,比如连接一次数据库
3. 初始体验
public static void main(String[] args) {
Person zhangsan = new Person(1, "zhangsan", 12, 0);
Person lisi = new Person(2, "lisi", 22, 1);
Person wangwu = new Person(3, "wangwu", 42, 0);
List<Person> list = new ArrayList<>();
list.add(zhangsan);
list.add(lisi);
list.add(wangwu);
//1. 遍历list每一个person
for (Person person : list) {
// System.out.println(person);
}
//1.1 jdk新语法--------------与js中forEach类似
//创建集合流
Stream<Person> stream = list.stream();
stream.forEach(item -> {
System.out.println(item);
});
//eg:打印出 status < 1的学生,并且按照年龄降序输出名字
//1. 创建一个集合流,每个元素是一个字符串
List<String> sList = list.stream()
.filter(item -> item.getStatus() < 1)// 先过滤
.sorted(Comparator.comparing(Person::getAge).reversed())//排序, 加了 reversed是降序
.map(Person::getName)// 遍历获取name字符串
.collect(Collectors.toList());//转成List集合
System.out.println(sList);// [wangwu, zhangsan]
}
//咋样实现 遍历同时需要Long类型转换成String类型;前端显示Long类型精度缺失
HkgCookbook db = this.baseMapper.selectById(id);
// List<Long> collect = hkgCookbookStms.stream().map(HkgCookbookStm::getStmId).collect(Collectors.toList());
ArrayList<String> stmIds =(ArrayList<String>) hkgCookbookStms.stream().map( item -> item.getStmId().toString()).collect(Collectors.toList());
db.setCookbookStmIds(stmIds);
js实现
let arr = [
{
name:"zhangsan",
age:12,
status:0
},{
name:"lisi",
age:32,
status:1
},{
name:"wangwu",
age:42,
status:0
}
]
//eg:打印出 status < 1的学生,并且按照年龄降序输出名字
let temp = arr.filter(item => item.status < 1)
.sort((a, b) => b.age - a.age)
.map(item => item.name);
console.log(temp)//["wangwu", "zhangsan"]
//扁平化
let arr2 = [ [1,2], [4,5], [9, 10] ];
console.log(arr2.flat())
是不是一模一样,我也不知道是谁模仿谁呢,应该js模仿java; 但是js没有延迟特性,需要闭包,promise解决。
4. 接下来深入了解 stream
4.1 创建流
- 创建数组流
//1.通过Arrays.stream
//1.1基本类型
int[] arr = new int[]{1,2,34,5};
IntStream intStream = Arrays.stream(arr);
//1.2引用类型
Student[] studentArr = new Student[]{new Student("s1",29),new Student("s2",27)};
Stream<Student> studentStream = Arrays.stream(studentArr);
//2.通过Stream.of
Stream<Integer> stream1 = Stream.of(1,2,34,5,65);
//注意生成的是int[]的流
Stream<int[]> stream2 = Stream.of(arr,arr);
stream2.forEach(System.out::println);
- 创建集合流
List<String> strs = Arrays.asList("11212","dfd","2323","dfhgf");
//创建普通流
Stream<String> stream = strs.stream();
//创建并行流
Stream<String> stream1 = strs.parallelStream();
- 创建空的流
//创建一个空的stream
Stream<Integer> stream = Stream.empty();
- 创建无限流
//创建无限流,通过limit提取指定大小
Stream.generate(()->"number"+new Random().nextInt()).limit(100).forEach(System.out::println);
Stream.generate(()->new Student("name",10)).limit(20).forEach(System.out::println);
- 创建规律的无限流
Stream.iterate(0,x->x+1).limit(10).forEach(System.out::println);
Stream.iterate(0,x->x).limit(10).forEach(System.out::println);
//Stream.iterate(0,x->x).limit(10).forEach(System.out::println);与如下代码意思是一样的
Stream.iterate(0, UnaryOperator.identity()).limit(10).forEach(System.out::println);
4.2 对stream操作
- 最常使用
- map,filter 和 js一样不用过多介绍
- sorted: 排序
String[] arr1 = {"abc","a","bc","abcd"};
/**
* Comparator.comparing是一个键提取的功能
* 以下两个语句表示相同意义
*/
@Test
public void testSorted1_(){
/**
* 按照字符长度排序
*/
Arrays.stream(arr1).sorted((x,y)->{
if (x.length()>y.length())
return 1;
else if (x.length()<y.length())
return -1;
else
return 0;
}).forEach(System.out::println);
Arrays.stream(arr1).sorted(Comparator.comparing(String::length)).forEach(System.out::println);
}
/**
* 倒序
* reversed(),java8泛型推导的问题,所以如果comparing里面是非方法引用的lambda表达式就没办法直接使用reversed()
* Comparator.reverseOrder():也是用于翻转顺序,用于比较对象(Stream里面的类型必须是可比较的)
* Comparator. naturalOrder():返回一个自然排序比较器,用于比较对象(Stream里面的类型必须是可比较的)
*/
@Test
public void testSorted2_(){
Arrays.stream(arr1).sorted(Comparator.comparing(String::length).reversed()).forEach(System.out::println);
Arrays.stream(arr1).sorted(Comparator.reverseOrder()).forEach(System.out::println);
Arrays.stream(arr1).sorted(Comparator.naturalOrder()).forEach(System.out::println);
}
/**
* thenComparing
* 先按照首字母排序
* 之后按照String的长度排序
*/
@Test
public void testSorted3_(){
Arrays.stream(arr1).sorted(Comparator.comparing(this::com1).thenComparing(String::length)).forEach(System.out::println);
}
public char com1(String x){
return x.charAt(0);
}
- flatMap: 拆解流: 和 flat相似
/**
* flapMap:拆解流
*/
@Test
public void testFlapMap1() {
String[] arr1 = {"a", "b", "c", "d"};
String[] arr2 = {"e", "f", "c", "d"};
String[] arr3 = {"h", "j", "c", "d"};
// Stream.of(arr1, arr2, arr3).flatMap(x -> Arrays.stream(x)).forEach(System.out::println);
Stream.of(arr1, arr2, arr3).flatMap(Arrays::stream).forEach(System.out::println);
}
- 提取流和组合流,和js contact相似
@Before
public void init(){
arr1 = new String[]{"a","b","c","d"};
arr2 = new String[]{"d","e","f","g"};
arr3 = new String[]{"i","j","k","l"};
}
/**
* limit,限制从流中获得前n个数据
*/
@Test
public void testLimit(){
Stream.iterate(1,x->x+2).limit(10).forEach(System.out::println);
}
/**
* skip,跳过前n个数据
*/
@Test
public void testSkip(){
// Stream.of(arr1).skip(2).limit(2).forEach(System.out::println);
Stream.iterate(1,x->x+2).skip(1).limit(5).forEach(System.out::println);
}
/**
* 可以把两个stream合并成一个stream(合并的stream类型必须相同)
* 只能两两合并
*/
@Test
public void testConcat(){
Stream<String> stream1 = Stream.of(arr1);
Stream<String> stream2 = Stream.of(arr2);
Stream.concat(stream1,stream2).distinct().forEach(System.out::println);
}
- 聚合操作, 和 js的 find findeIndex findLastIndex indexof reduce
@Before
public void init(){
arr = new String[]{"b","ab","abc","abcd","abcde"};
}
/**
* max、min
* 最大最小值
*/
@Test
public void testMaxAndMin(){
Stream.of(arr).max(Comparator.comparing(String::length)).ifPresent(System.out::println);
Stream.of(arr).min(Comparator.comparing(String::length)).ifPresent(System.out::println);
}
/**
* count
* 计算数量
*/
@Test
public void testCount(){
long count = Stream.of(arr).count();
System.out.println(count);
}
/**
* findFirst
* 查找第一个
*/
@Test
public void testFindFirst(){
String str = Stream.of(arr).parallel().filter(x->x.length()>3).findFirst().orElse("noghing");
System.out.println(str);
}
/**
* findAny
* 找到所有匹配的元素
* 对并行流十分有效
* 只要在任何片段发现了第一个匹配元素就会结束整个运算
*/
@Test
public void testFindAny(){
Optional<String> optional = Stream.of(arr).parallel().filter(x->x.length()>3).findAny();
optional.ifPresent(System.out::println);
}
/**
* anyMatch
* 是否含有匹配元素
*/
@Test
public void testAnyMatch(){
Boolean aBoolean = Stream.of(arr).anyMatch(x->x.startsWith("a"));
System.out.println(aBoolean);
}
@Test
public void testStream1() {
Optional<Integer> optional = Stream.of(1,2,3).filter(x->x>1).reduce((x,y)->x+y);
System.out.println(optional.get());
}
- Optional类型
通常聚合操作会返回一个Optional类型,Optional表示一个安全的指定结果类型,所谓的安全指的是避免直接调用返回类型的null值而造成空指针异常,调用optional.ifPresent()可以判断返回值是否为空,或者直接调用ifPresent(Consumer<? super T> consumer)在结果部位空时进行消费操作;调用optional.get()获取返回值。通常的使用方式如下:
@Test
public void testOptional() {
List<String> list = new ArrayList<String>() {
{
add("user1");
add("user2");
}
};
Optional<String> opt = Optional.of("andy with u");
opt.ifPresent(list::add);
list.forEach(System.out::println);
}
使用Optional可以在没有值时指定一个返回值,例如
@Test
public void testOptional2() {
Integer[] arr = new Integer[]{4,5,6,7,8,9};
Integer result = Stream.of(arr).filter(x->x>9).max(Comparator.naturalOrder()).orElse(-1);
System.out.println(result);
Integer result1 = Stream.of(arr).filter(x->x>9).max(Comparator.naturalOrder()).orElseGet(()->-1);
System.out.println(result1);
Integer result2 = Stream.of(arr).filter(x->x>9).max(Comparator.naturalOrder()).orElseThrow(RuntimeException::new);
System.out.println(result2);
}
- 收集结果, 可以把stream 收集成自己想要的数据结构,收集结果目的就是统计
/**
* 生成List
*/
List<Student> list = Arrays.stream(students).collect(toList());
list.forEach((x)-> System.out.println(x));
/**
* 生成Set
*/
Set<Student> set = Arrays.stream(students).collect(toSet());
set.forEach((x)-> System.out.println(x));
/**
* 如果包含相同的key,则需要提供第三个参数,否则报错
*/
Map<String,Integer> map = Arrays.stream(students).collect(toMap(Student::getName,Student::getScore,(s,a)->s+a));
map.forEach((x,y)-> System.out.println(x+"->"+y));
/**
* 生成数组
*/
Student[] s = Arrays.stream(students).toArray(Student[]::new);
/**
* 指定生成的类型
*/
@Test
public void testCollect3(){
HashSet<Student> s = Arrays.stream(students).collect(toCollection(HashSet::new));
s.forEach(System.out::println);
}
//收集结果目的就是统计
/**
* 统计
*/
@Test
public void testCollect4(){
IntSummaryStatistics summaryStatistics = Arrays.stream(students).collect(Collectors.summarizingInt(Student::getScore));
System.out.println("getAverage->"+summaryStatistics.getAverage());
System.out.println("getMax->"+summaryStatistics.getMax());
System.out.println("getMin->"+summaryStatistics.getMin());
System.out.println("getCount->"+summaryStatistics.getCount());
System.out.println("getSum->"+summaryStatistics.getSum());
}
- 分组和分片,要想达到自己想要的结果,必须先提前想好自己的收集结果的数据结构;
前端一般喜欢数据是树形的,方便前端做分组渲染,但是如果后台不处理数据分组,前端也可以进行数据分组渲染,这个看前后端之间的默契
分组和分片的意义是,将collect的结果集展示位Map<key,val>的形式,通常的用法如下:
//分组和分片
public static void test3() {
Person zhangsan = new Person(1, "zhangsan", 12, 0);
Person lisi = new Person(2, "lisi", 22, 1);
Person wangwu = new Person(3, "wangwu", 42, 0);
Person zhaosi = new Person(4, "zhaosi", 60, 2);
List<Person> list = new ArrayList<>();
list.add(zhangsan);
list.add(lisi);
list.add(wangwu);
list.add(zhaosi);
//eg: status:0-男生,1-女生,2-保密 进行分组
//分组后,是以status为key, 对应的list为value
Map<Integer, List<Person>> contentMap = list.stream().collect(groupingBy(Person::getStatus));
contentMap.forEach((k,v) -> System.out.println(k + "->" + v));
//分组后,可以指定value的类型
Map<Integer, Set<Person>> contentMap2 = list.stream().collect(groupingBy(Person::getStatus, toSet()));
contentMap2.forEach((k,v) -> System.out.println(k + "->" + v));
// 聚合操作,就是统计一些 个数,对象属性累加,最大的对象,
//counting: 个数
Map<String, Long> contentMap3 = list.stream().collect(groupingBy(Person::getName, counting()));
contentMap3.forEach((k,v) -> System.out.println(k + "->" + v));
//summingInt: 累加
Map<Integer, Integer> contentMap4 = list.stream().collect(groupingBy(Person::getStatus, summingInt(Person::getAge)));
contentMap4.forEach((k,v) -> System.out.println(k + "->" + v));
//maxBy: 最大值
Map<Integer, Optional<Person>> contentMap5 = list.stream().collect(groupingBy(Person::getStatus, maxBy(Comparator.comparing(Person::getAge))));
contentMap5.forEach((k,v) -> System.out.println(k + "->" + v));
//mapping:统计出性别对应的年龄
Map<Integer, Set<Integer>> contentMap6 = list.stream().collect(groupingBy(Person::getStatus, mapping(Person::getAge, toSet())));
contentMap6.forEach((k,v) -> System.out.println(k + "->" + v));
}
js实现分组
let arr = [
{
name:"zhangsan",
age:12,
status:0
},{
name:"lisi",
age:32,
status:1
},{
name:"wangwu",
age:42,
status:0
}
]
//分组,自己可以定制化 map的value结构,比较简单
//方式一
let map = new Map();
arr.forEach(item => {
if(map.get(item.status)){
let arr = map.get(item.status);
arr.push(item);
map.set(item.status,arr);
}else {
map.set(item.status, [item]) //java put
}
})
// console.log(map);
console.log("--------------------------------")
//方式二
let obj = arr.reduce((pre,cur) => {
if(pre[cur.status]) {
let arr = pre[cur.status].concat([cur]);
pre[cur.status] = arr;
}else {
console.log('err', pre[cur.status])
pre[cur.status] = [cur]
console.log('err2', pre[cur.status])
}
return pre;
}, {})
console.log(obj);
5.原始流
在数据量比较大的情况下,将基本数据类型(int,double...)包装成相应对象流的做法是低效的,因此,我们也可以直接将数据初始化为原始类型流,在原始类型流上的操作与对象流类似,我们只需要记住两点
1.原始类型流的初始化
2.原始类型流与流对象的转换
DoubleStream doubleStream;
IntStream intStream;
/**
* 原始类型流的初始化
*/
@Before
public void testStream1(){
doubleStream = DoubleStream.of(0.1,0.2,0.3,0.8);
intStream = IntStream.of(1,3,5,7,9);
IntStream stream1 = IntStream.rangeClosed(0,100);
IntStream stream2 = IntStream.range(0,100);
}
/**
* 流与原始类型流的转换
*/
@Test
public void testStream2(){
Stream<Double> stream = doubleStream.boxed();
doubleStream = stream.mapToDouble(Double::new);
}
6. 并行流
可以将普通顺序执行的流转变为并行流,只需要调用顺序流的parallel() 方法即可,如Stream.iterate(1, x -> x + 1).limit(10).parallel()。
1) 并行流的执行顺序
我们调用peek方法来瞧瞧并行流和串行流的执行顺序,peek方法顾名思义,就是偷窥流内的数据,peek方法声明为Stream<T> peek(Consumer<? super T> action);加入打印程序可以观察到通过流内数据,见如下代码:
public void peek1(int x) {
System.out.println(Thread.currentThread().getName() + ":->peek1->" + x);
}
public void peek2(int x) {
System.out.println(Thread.currentThread().getName() + ":->peek2->" + x);
}
public void peek3(int x) {
System.out.println(Thread.currentThread().getName() + ":->final result->" + x);
}
/**
* peek,监控方法
* 串行流和并行流的执行顺序
*/
@org.junit.Test
public void testPeek() {
Stream<Integer> stream = Stream.iterate(1, x -> x + 1).limit(10);
stream.peek(this::peek1).filter(x -> x > 5)
.peek(this::peek2).filter(x -> x < 8)
.peek(this::peek3)
.forEach(System.out::println);
}
@Test
public void testPeekPal() {
Stream<Integer> stream = Stream.iterate(1, x -> x + 1).limit(10).parallel();
stream.peek(this::peek1).filter(x -> x > 5)
.peek(this::peek2).filter(x -> x < 8)
.peek(this::peek3)
.forEach(System.out::println);
}
网友评论