stream流map多个字段_Java8⽤了这么久了，Stream流⽤法
及语法你都知道吗？
1.简介
Stream流 最全的⽤法
Stream 能⽤来⼲什么？⽤来处理集合，通过 使⽤Stream API 对集合数据进⾏操作，就类似于使⽤ SQL 执⾏的数据库查询，Stream API 提供了⼀种⾼效且易于使⽤的处理数据的⽅式
为什么⽤Java 8 Stream ？因为 操作简单
为什么操作简单?因为 Lambda 表达式，它极⼤的提⾼了编程效率和程序可读性
怎么操作流？ ⾸先你的有个数据源(数组、集合)，操作会产⽣新的流对象，原来的流对象不会改变
流⽤法有结束操作，这种代码不是你写了⼀个⽅法就执⾏⼀个⽅法，⽽是最后触发结束操作的时候才统⼀执⾏的，collect、foreach ⽅法就是⼀种结束⽅法，详情看代码及结果参考 2.映射map、flatMap⽤法 部分
2.具体⽤法
2.1 创建流
// 集合创建流
List list = new ArrayList<>();
// 获取⼀个顺序流
Stream listStream = list.stream();
// 获取⼀个并⾏流
Stream parallelListStream = list.parallelStream();
java中split的用法// 数组创建流
Integer[] nums = new Integer[] { 1, 2, 3, 4, 5 };
Stream arrStream = Arrays.stream(nums);
arrStream.forEach(System.out::println);// 1 2 3 4 5
// 静态⽅法of创建流
Stream ofStream = Stream.of(1, 2, 3, 4, 5);
ofStream.forEach(System.out::println);// 1 2 3 4 5
// 静态⽅法iterate 创建流
Stream iterateStream = Stream.iterate(1, (x) -> x + 10).limit(4);
iterateStream.forEach(System.out::println); // 1 11 21 31
// 静态⽅法generate 创建流
Stream generateStream = ate(Math::random).limit(2);
generateStream.forEach(System.out::println);
2.2 操作流
1.过滤
filter：过滤流中的某些元素(可以做⼀些基本的判空、替换、判断逻辑操作)
limit(n)：获取n个元素，结果获取⼏个元素
skip(n)：跳过n元素，配合limit(n)可实现分页
distinct：通过流中元素的 hashCode() 和 equals() 去除重复元素
//filter 判空
Stream notNullStreamObj = Stream.of(1, 2, null, 4, 5, 6, 7, null, 2);
Stream notNullStream = notNullStreamObj.filter(i -> (null != i));
notNullStream.forEach(System.out::println);//1 2 4 5 6 7 2
//filter 逻辑判断
Stream logicStreamObj = Stream.of(1, 2, null, 4, 5, 6, 7, null, 2);
Stream logicStream = logicStreamObj.filter(i -> (i != null && i > 5));
logicStream.forEach(System.out::println); // 6 7
//filter 替换
Stream strStreamObj = Stream.of("aa", "ab", null, "ac", "bd", "ee");
Stream strStream = strStreamObj.filter(str -> (null != str && ains("a")));
strStream.forEach(System.out::println); // aa ab ac
//skip 跳过
Stream skipStreamObj = Stream.of("aa", "ab", null, "ac", "bd", "ee");
Stream skipStream = skipStreamObj.skip(2);
skipStream.forEach(System.out::println); // null ac bd ee
//distinct 去重
Stream disStreamObj = Stream.of("aa", "ab", null, "ac", "aa", "ab", null, "ee");
Stream disStream = disStreamObj.distinct();
disStream.forEach(System.out::println); // aa ab null ac ee
2.映射
map：接收⼀个函数作为参数，该函数会被应⽤到每个元素上，映射成⼀个新的元素。
flatMap：接收⼀个函数作为参数，将流中的每个值都换成另⼀个流，然后把所有流连接成⼀个流。
peek：这个操作很骚，类似map只不过map 是Func函数，提供返回值，⽽peer是取出元素，Consumer表达式设值，我个⼈觉得没啥区别呢，官⽅⽂档提⽰：该⽅法主要⽤于调试，做⼀些消耗这个对象但不修改它的东西，没啥事不要⽤
很想问⼀下 这俩map、flatMap 区别 ，细品，你细品，你细细品
map是将每个元素 映射成⼀个新元素，除⾮你过滤了，否则不会改变元素个数
flatMap是将原流中的每个值都变成另⼀个流，然后把流合并串起来，必须有返回值，拼装成新的流
//map 把包含a的元素，替换成| 注意，注意， 元素还是⼀个整体，对每个元素
Stream mapStreamObj = Stream.of("a,b,c", "a,e,f", "g,h,i");
Stream mapStream = mapStreamObj.map(str -> placeAll(",", "|"));
mapStream.forEach(System.out::println); // a|b|c a|e|f h|i|j
//flatMap 可以把元素 切分后，再按照新元素组成新的字符串
Stream flatMapStreamObj = Stream.of("a,b,c", "a,e,f", "g,h,i");
Stream flatMapStream = flatMapStreamObj.flatMap(str -> {
String[] arr = str.split(",");
Stream result = Arrays.stream(arr);
return result;
});
flatMapStream.forEach(System.out::println); //a b c d e f g h i
System.out.println("1===========");
Stream peekStreamObj = Stream.of("a,b,c", "a,e,f", "g,h,i");
Stream peekStream = peekStreamObj.peek(e -> System.out.println("Filtered value: " + e)) .map(String::toUpperCase)
.peek(e -> System.out.println("Mapped value: " + e));
System.out.println("2=========== peek代码结束，但是⽇志没打印");
Set stringSet = Set());
System.out.println("3=========== collect结束操作，代码⽇志打印");
stringSet.forEach(System.out::println);
map执⾏结果
//看下执⾏结果，说明 collect才是结束操作，代码结束，但是并不是真正结束
1===========
2=========== peek代码结束，但是⽇志没打印
Filtered value: a,b,c
Mapped value: A,B,C
Filtered value: a,e,f
Mapped value: A,E,F
Filtered value: g,h,i
Mapped value: G,H,I
3=========== collect结束操作，代码⽇志打印
A,B,C
A,E,F
G,H,I
3.排序
sorted()：⾃然排序，流中元素需实现Comparable接⼝
sorted(Comparator com)：定制排序，⾃定义Comparator排序器先构建⼀个User类
public static class User {
private String name;
private Integer age;
public User(String name, Integer age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
然后 看下sort⽤法
//按字母排序
Stream sortStreamObj = Stream.of("a,e,f", "a,d,c", "a,b,i"); Stream sortStream = sortStreamObj.sorted();
sortStream.forEach(System.out::println); //abi adc aef
User u1 = new User("bb", 1);
User u2 = new User("aa", 2);
User u3 = new User("cc", 3);
User u4 = new User("aa", 4);
Set userSet = wHashSet(u1, u2, u3, u4);
Stream userStream = userSet.stream().sorted(
(obj1, obj2) -> {
if (Name().Name())) {
//name相等 按age
Age() - Age();
}
Name()Name());
}
);
userStream.forEach(System.out::println);// u2 u4 u1 u3
sort 执⾏结果
a,b,i
a,d,c
a,e,f
User{name='aa', age=2}
User{name='aa', age=4}
User{name='bb', age=1}
User{name='cc', age=3}
4.流匹配
allMatch：接收⼀个 Predicate 函数，当流中每个元素都符合该断⾔时才返回true，否则返回false noneMatch：接收⼀个 Predicate 函数，当流中每个元素都不符合该断⾔时才返回true，否则返回false anyMatch：接收⼀个 Predicate 函数，只要流中有⼀个元素满⾜该断⾔则返回true，否则返回false findFirst：返回流中第⼀个元素
findAny：返回流中的任意元素
count：返回流中元素的总个数
max：返回流中元素最⼤值
min：返回流中元素最⼩值
List numLists = Arrays.asList(3, 4, 5, 6, 10);
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论