java 8 stream流
文章目录
- Stream将list转换为Set
- Stream将list转换为Map
- Stream将Reduce 求和
- StreamMax和Min
- StreamMatch 匹配
- StreamFor循环
- Stream过滤器
- Stream排序 sorted
- Stream limit和skip
什么是stream流
- Stream 是JDK1.8 中处理集合的关键抽象概念,Lambda 和 Stream 是JDK1.8新增的函数式编程最有亮点的特性了,它可以指定你希望对集合进行的操作,可以执行非常复杂的查找、过滤和映射数据等操作。
- 使用Stream API 对集合数据进行操作,就类似于使用SQL执行的数据库查询。Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。Stream API可以极大提高Java程序员的生产力,让程序员写出高效率、干净、简洁的代码。
- 这种风格将要处理的元素集合看作一种流, 流在管道中传输, 并且可以在管道的节点上进行处理, 比如筛选, 排序,聚合等
- 元素流在管道中经过中间操作(intermediate operation)的处理,最后由最终操作(terminal operation)得到前面处理的结果。
Stream :非常方便精简的形式遍历集合实现 过滤、排序等。
Mysql:select userName from mayikt where userName =‘mayikt’
Order by age limt(0,2)
中间操作 filter 过滤器
;distinct 去重;
sorted 排序
; limit 分页
终止操作: forEach 遍历; collect 转换; min max; allMatch 条件;
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2EG2PGtG-1638614292364)(C:\Users\LENOVO\AppData\Roaming\Typora\typora-user-images\1638613363137.png)]
Stream创建方式
- parallelStream为并行流采用多线程执行
- Stream采用单线程执行
parallelStream效率比Stream要高。
/**
* 并行流与串行流区别
*
*
* 串行流:单线程的方式操作; 数据量比较少的时候。
* 并行流:多线程方式操作;数据量比较大的时候,原理:
* Fork join 将一个大的任务拆分n多个小的子任务并行执行,
* 最后在统计结果,有可能会非常消耗cpu的资源,确实可以
* 提高效率。
*
*
* 注意:数据量比较少的情况下,不要使用并行流。
*/
Stream将list转换为Set
public class Test01 {
public static void main(String[] args) {
ArrayList<UserEntity> userEntities = new ArrayList<>();
userEntities.add(new UserEntity("meite", 28));
userEntities.add(new UserEntity("zhangsan", 35));
userEntities.add(new UserEntity("xiaowei", 16));
userEntities.add(new UserEntity("xiaowei", 16));
userEntities.forEach((t) -> {
System.out.println(t.toString());
});
System.out.println("+++++++");
Stream<UserEntity> stream = userEntities.stream();
Set<UserEntity> setUserList = stream.collect(Collectors.toSet());
setUserList.forEach((userEntity -> {
System.out.println(userEntity.toString());
}));
}
}
Stream将list转换为Map
package com.nie.stream;
import com.nie.entity.UserEntity;
import java.util.ArrayList;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* @Author DaZhao
* @Date 2021/12/1 16:16
* @Version 1.0
*/
public class Test02 {
public static void main(String[] args) {
ArrayList<UserEntity> userEntities = new ArrayList<>();
userEntities.add(new UserEntity("meite", 28));
userEntities.add(new UserEntity("zhangsan", 35));
userEntities.add(new UserEntity("xiaowei", 16));
// userEntities.add(new UserEntity("xiaowei", 16));
Stream<UserEntity> stream = userEntities.stream();
// key为string类型 Value userEntity集合中的数据: UserEntity string类型
/**
* 内部内写法
*/
Map<String, UserEntity> collect = stream.collect(Collectors.toMap(new Function<UserEntity, String>() {
@Override
public String apply(UserEntity userEntity) {
return userEntity.getName();
}
}, new Function<UserEntity, UserEntity>() {
@Override
public UserEntity apply(UserEntity userEntity) {
return userEntity;
}
}));
collect.forEach(new BiConsumer<String, UserEntity>() {
@Override
public void accept(String s, UserEntity userEntity) {
System.out.println("S:" + s + ",:" + userEntity.toString());
}
});
/**
* lambda 表达式写法
*/
Map<String, UserEntity> collect1 = stream.collect(Collectors.toMap(userEntity -> userEntity.getName(), userEntity -> userEntity));
collect1.forEach((s, userEntity) -> System.out.println("S:" + s + ",:" + userEntity.toString()));
}
}
Stream将Reduce 求和
package com.nie.stream;
import com.nie.entity.UserEntity;
import java.util.ArrayList;
import java.util.Optional;
import java.util.Set;
import java.util.function.BinaryOperator;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* @Author DaZhao
* @Date 2021/12/1 16:16
* @Version 1.0
*/
public class Test03 {
public static void main(String[] args) {
/**
* 求和
*/
// Stream<Integer> stream = Stream.of(10, 20, 30);
// Optional<Integer> reduce = stream.reduce(new BinaryOperator<Integer>() {
// @Override
// public Integer apply(Integer integer, Integer integer2) {
// return integer + integer2;
// }
// });
// System.out.println(reduce.get());
ArrayList<UserEntity> userEntities1 = new ArrayList<>();
userEntities1.add(new UserEntity("meite", 28));
userEntities1.add(new UserEntity("zhangsan", 35));
userEntities1.add(new UserEntity("xiaowei", 16));
Stream<UserEntity> stream = userEntities1.stream();
Optional<UserEntity> sum = stream.reduce((userEntity, userEntity2) -> {
UserEntity sum1 = new UserEntity("sum", userEntity.getAge() + userEntity2.getAge());
return sum1;
});
System.out.println(sum.get());
}
}
StreamMax和Min
package com.nie.stream;
import com.nie.entity.UserEntity;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* @Author DaZhao
* @Date 2021/12/1 16:16
* @Version 1.0
*/
/**
* 最大最小的
*/
public class Test04 {
public static void main(String[] args) {
ArrayList<UserEntity> userEntities = new ArrayList<>();
userEntities.add(new UserEntity("meite", 28));
userEntities.add(new UserEntity("zhangsan", 35));
userEntities.add(new UserEntity("xiaowei", 16));
userEntities.add(new UserEntity("xiaowei", 16));
Stream<UserEntity> stream = userEntities.stream();
Stream<UserEntity> stream2 = userEntities.stream();
//最小
Optional<UserEntity> min = stream.min((o1, o2) -> o1.getAge() - o2.getAge());
System.out.println(min.get());
//最大
Optional<UserEntity> max = stream2.max((o1, o2) -> o1.getAge() - o2.getAge());
System.out.println(max.get());
}
}
StreamMatch 匹配
- anyMatch表示,判断的条件里,任意一个元素成功,返回true
- allMatch表示,判断条件里的元素,所有的都是,返回true
- noneMatch跟allMatch相反,判断条件里的元素,所有的都不是,返回true
package com.nie.stream;
import com.nie.entity.UserEntity;
import java.util.ArrayList;
import java.util.Optional;
import java.util.function.Predicate;
import java.util.stream.Stream;
/**
* @Author DaZhao
* @Date 2021/12/1 16:16
* @Version 1.0
*/
/**
* streamMatch匹配
* <p>
* anyMatch表示 判断任意一个元素 人一个返回 true
* allMatch表示 判断条件里的元素 都是返回true
* noneMatch和allMatch相反
*/
public class Test05 {
public static void main(String[] args) {
ArrayList<UserEntity> userEntities = new ArrayList<>();
userEntities.add(new UserEntity("meite", 28));
userEntities.add(new UserEntity("zhangsan", 35));
userEntities.add(new UserEntity("xiaowei", 16));
userEntities.add(new UserEntity("xiaowei", 16));
Stream<UserEntity> stream = userEntities.stream();
// boolean meite = stream.anyMatch(new Predicate<UserEntity>() {
// @Override
// public boolean test(UserEntity userEntity) {
// return userEntity.getName().equals("meite");
// }
// });
// System.out.println(meite);
System.out.println(stream.noneMatch(new Predicate<UserEntity>() {
@Override
public boolean test(UserEntity userEntity) {
return userEntity.getAge() > 15;
}
}));
}
}
>>>>>>>> false
StreamFor循环
/**
* @Author DaZhao
* @Date 2021/12/1 16:16
* @Version 1.0
*/
/**
* streamFor 循环
*/
public class Test06 {
public static void main(String[] args) {
ArrayList<UserEntity> userEntities = new ArrayList<>();
userEntities.add(new UserEntity("meite", 28));
userEntities.add(new UserEntity("zhangsan", 35));
userEntities.add(new UserEntity("xiaowei", 16));
userEntities.add(new UserEntity("xiaowei", 16));
Stream<UserEntity> stream = userEntities.stream();
stream.forEach(userEntity -> System.out.println(userEntity.toString()));
}
}
Stream过滤器
/**
* @Author DaZhao
* @Date 2021/12/1 16:16
* @Version 1.0
*/
/**
* stream filter 过滤器
*/
public class Test07 {
public static void main(String[] args) {
ArrayList<UserEntity> userEntities = new ArrayList<>();
userEntities.add(new UserEntity("meite", 28));
userEntities.add(new UserEntity("zhangsan", 35));
userEntities.add(new UserEntity("xiaowei", 16));
userEntities.add(new UserEntity("xiaowei", 16));
Stream<UserEntity> stream = userEntities.stream();
stream.filter(new Predicate<UserEntity>() {
@Override
public boolean test(UserEntity userEntity) {
return userEntity.getAge()>20;
}
}).filter(new Predicate<UserEntity>() {
@Override
public boolean test(UserEntity userEntity) {
return userEntity.getName().equals("zhangsan");
}
}).forEach(new Consumer<UserEntity>() {
@Override
public void accept(UserEntity userEntity) {
System.out.println(userEntity.toString());
}
});
stream.filter(userEntity -> userEntity.getAge()>20)
.filter(userEntity -> userEntity.getName().equals("zhangsan"))
.forEach(userEntity -> System.out.println(userEntity.toString()));
}
}
Stream排序 sorted
/**
* stream sorted 排序
*/
public class Test08 {
public static void main(String[] args) {
ArrayList<UserEntity> userEntities = new ArrayList<>();
userEntities.add(new UserEntity("meite", 28));
userEntities.add(new UserEntity("zhangsan", 35));
userEntities.add(new UserEntity("xiaowei", 16));
userEntities.add(new UserEntity("xiaowei", 16));
Stream<UserEntity> stream = userEntities.stream();
stream.sorted(new Comparator<UserEntity>() {
@Override
public int compare(UserEntity o1, UserEntity o2) {
return o1.getAge() - o2.getAge();
}
}).forEach(new Consumer<UserEntity>() {
@Override
public void accept(UserEntity userEntity) {
System.out.println(userEntity);
}
});
stream.sorted((o1, o2) -> o1.getAge() - o2.getAge())
.forEach(userEntity -> System.out.println(userEntity));
}
}
Stream limit和skip
- Limit 从头开始获取
- Skip 就是跳过
/**
* stream limit和skip
* limit 从头开始跳
* skip 就是跳过
*/
public class Test09 {
public static void main(String[] args) {
ArrayList<UserEntity> userEntities = new ArrayList<>();
userEntities.add(new UserEntity("meite", 28));
userEntities.add(new UserEntity("zhangsan", 35));
userEntities.add(new UserEntity("xiao", 16));
userEntities.add(new UserEntity("xiaowei", 16));
Stream<UserEntity> stream = userEntities.stream();
stream.skip(2).limit(1).forEach(userEntity -> System.out.println(userEntity));
}
}
>>>>>>>>>>>> UserEntity{name='xiao', age=16}
Stream 综合案例
/**
* @Author DaZhao
* @Date 2021/12/1 16:16
* @Version 1.0
*/
/**
* 综合案例
*/
public class Test010 {
public static void main(String[] args) {
ArrayList<UserEntity> userEntities = new ArrayList<>();
userEntities.add(new UserEntity("mayikt", 20));
userEntities.add(new UserEntity("meite", 28));
userEntities.add(new UserEntity("zhangsan", 35));
userEntities.add(new UserEntity("xiaowei", 16));
userEntities.add(new UserEntity("mayikt_list", 109));
userEntities.add(new UserEntity("mayikt_zhangsan", 110));
userEntities.add(new UserEntity("lisi", 109));
Stream<UserEntity> stream = userEntities.stream();
//要求:对数据流的数据实现降序排列、且名称包含mayikt 获取前两位
stream.sorted(new Comparator<UserEntity>() {
@Override
public int compare(UserEntity o1, UserEntity o2) {
return -(o1.getAge() - o2.getAge());
}
}).filter(new Predicate<UserEntity>() {
@Override
public boolean test(UserEntity userEntity) {
return userEntity.getName().contains("mayikt");
}
}).limit(2).forEach(new Consumer<UserEntity>() {
@Override
public void accept(UserEntity userEntity) {
System.out.println(userEntity.toString());
}
});
stream.sorted((o1, o2) -> -(o1.getAge() - o2.getAge()))
.filter(userEntity -> userEntity.getName().contains("mayikt"))
.limit(2)
.forEach(userEntity -> System.out.println(userEntity.toString()));
}
}