java list数据合并到string java stream 合并list

list.stream().mapToDouble(User::getHeight).sum()//和
list.stream().mapToDouble(User::getHeight).max()//最大
list.stream().mapToDouble(User::getHeight).min()//最小
list.stream().mapToDouble(User::getHeight).average()//平均值

有关java Stream 流式处理得详细列子：

package com.wyz.streamApisToMap;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.OptionalInt;
import java.util.stream.Collectors;
import java.util.IntSummaryStatistics;
import java.util.Map;
public class StreamAPi {
public static void main(String[] args){
// 初始化
List integerList = Arrays.asList(1,2,3,4,5,6,7,6,5,4,3,2,1);
int sumR = 0;
for(int i =0;i
sumR += integerList.get(i);
}
System.out.println("普通求和："+sumR);
//过滤，收集所有偶数
List collect = integerList.stream()
.filter(Integer-> Integer%2 == 0)
.collect(Collectors.toList());
System.out.println("过滤，收集所有偶数："+collect);
int sum = integerList.stream().mapToInt(Integer::intValue).sum();
System.out.println("计算总和："+sum);
// 计算求和
int reduce = integerList.stream()
.mapToInt(Integer::intValue)
.reduce(0, Integer::sum);
System.out.println("计算总和，带初始值："+reduce);
OptionalInt reduce1 =integerList.stream()
.mapToInt(Integer::intValue)
.reduce(Integer::sum);
System.out.println("计算总和，OptiionalInt :"+reduce1);
int reduce2 = integerList.stream()
.reduce(0, (a,b)->a+b);
System.out.println("计算总和："+reduce2);
//计算数量
long count = integerList.stream().count();
System.out.println("计算数量"+count);
Optional collect8 = integerList.stream().collect(Collectors.maxBy((x1,x2)->x1-x2));
Optional collect9 = integerList.stream().collect(
Collectors.maxBy(Comparator.comparing(Integer::intValue)));
if(collect8.isPresent()){
System.out.println("求最大值："+collect8.get());
}
if(collect9.isPresent()){
System.out.println("求最大值："+collect9.get());
}
Optional collect10 = integerList.stream().collect(Collectors.
minBy(Comparator.comparing(Integer::intValue)));
if(collect10.isPresent()){
System.out.println("求最小值："+collect10.get());
}
// 求平均值
Double collect11 = integerList.stream().collect(Collectors.averagingInt(Integer::intValue));
System.out.println("平均值："+collect11);
// 一次性得到元素个数、总和、均值、最大值、最小值
IntSummaryStatistics collect12 = integerList.stream().collect(Collectors.summarizingInt(Integer::intValue));
System.out.println("一次性得到元素个数、总和、均值、最大值、最小值："+collect12);
//分组
Map> collect15 = integerList.stream().collect(
Collectors.groupingBy(Integer::intValue)
);
System.out.println("分组："+collect15);
Map collect14 = integerList.stream().collect(
Collectors.groupingBy(Integer::intValue, Collectors.counting())
);
System.out.println("可以有多级分组："+collect14);
//分区可以看做是分组的一种特殊情况，在分区中key只有两种情况：true 或false
Map> collect16 = integerList.stream().collect(Collectors.partitioningBy(x->x >= 7));
System.out.println("分区可以看做是分组的一种特殊情况，在分区中key 只有两种情况：true或false:"+collect16);
// 去重
List collect1 = integerList
.stream()
.distinct()
.collect(Collectors.toList());
System.out.println("去重："+collect1);
//limit 返回包含前n个元素的流
List collect2 = integerList
.stream()
.filter(Integer-> Integer %2==0)
.limit(2).collect(Collectors.toList());
System.out.println("limit:"+collect2);
//排序 倒叙排序
List collect3 = integerList.stream()
.sorted((s1,s2)->s2-s1)
.collect(Collectors.toList());
System.out.println("排序:"+collect3);
// 跳过前n个元素
List collect4 = integerList.stream()
.filter(Integer -> Integer %2==1).skip(3)
.collect(Collectors.toList());
System.out.println("skip:"+collect4);
String[] strs = {"java8","is","easy","to","use"};
//字符串拼接
String collect13 = Arrays.stream(strs).collect(Collectors.joining());
System.out.println("字符串拼接："+collect13);
List collect5 = Arrays.stream(strs)
.map(s->s.split(""))// 每个字符串映射成string
.flatMap(Arrays::stream)
.collect(Collectors.toList());
System.out.println("将字符串映射成字符数组："+collect5);
//FlatMap 是将一个流中的每个值都转换成一个个流，然后再将这些流扁平化成为一个流
List collect7 = Arrays.stream(strs)
.map(s->s.split("")) // 每个字符串映射成string[]
.flatMap(Arrays::stream) // flatMap 将由Map 映射得到的Stream，转换成由各个字符串数组映射成的流Stream
.collect(Collectors.toList());
System.out.println("flatMap是将一个流中的每个值都转成一个个流，然后再将这些流扁平化成为一个流:" + collect7);
List collect6 = Arrays.stream(strs)
.map(s->s.split(""))
.flatMap(Arrays::stream)
.distinct()
.collect(Collectors.toList());
System.out.println("多个字符串，将各个字符串拆开去重："+collect6);
// allMatch 检测是否全部满足指定的参数行为
boolean b = integerList.stream().allMatch(Integer->Integer>5);
System.out.println("allMatch,检测是否全部都满足指定的参数行为："+b);
// anyMatch 检测是否存在一个或者多个满足指定的参数行为
boolean any = integerList.stream().anyMatch(Integer->Integer >5);
System.out.println("anyMatch,检测是否存在一个或多个满足指定的参数行为："+any);
// nonMatch 检测是否不存在满足指定行为的元素
boolean non = integerList.stream().noneMatch(Integer ->Integer >5);
System.out.println("检测是否不存在满足指定行为的元素："+non);
//返回满足条件的第一个元素
Optional first = integerList.stream().filter(Integer->Integer >6).findFirst();
if(first.isPresent()){
System.out.println("用于返回满足条件的第一个元素:"+first.get());
}
// findAny 相对于findFirs 区别在于 findAny 不一定返回第一个而是返回任意一个
// 实际上对于顺序流式处理而言，findFirst和findAny 返回的结果是一样的，
// 至于为什么会这样设计，当我们启用并行流式处理的时候，查找第一个元素往往会有很多限制，如果不式特别需求，
// 在并行流式处理中使用findAny的性能要比findFirst 好
Optional any1 = integerList.stream().filter(Integer->Integer >1).distinct().findAny();
if(any1.isPresent()){
System.out.println("findAny 不一定返回第一个，而是返回任意一个："+any1.get());
}
//？ 启动并行流式处理虽然简单，只需要将Sream()替换成parallelStream()即可，
// 但既然是并行，就会设计到多现场安全问题，所以在启用之前要确认并行是否值得
//(并行得效率不一定高于顺序执行)，另外就要保证线程安全。此两项无法保证，
// 那么并行毫无意义，毕竟结果比速度更加重
Optional any2 = integerList.parallelStream().filter(Integer -> Integer >1)
.distinct().findAny();
if(any2.isPresent()){
System.out.println("并行流式处理："+any2.get());
}
}
}

3.有关对象的数据过滤

//查找身高在1.8米及以上的男生
List boys = studentList.stream().filter(s->s.getGender() && s.getHeight() >= 1.8).collect(Collectors.toList());
//输出查找结果
StudentInfo.printStudents(boys);