Stream流中常用的方法（2）

统计

针对简单类型IntStream、LongStream和DoubleStream

Random r = new Random();
List<Integer> list = r.ints().limit(10).mapToObj(Integer::valueOf)
.collect(Collectors.toList());
int[] arr=new int[list.size()];
for(int i=0;i<list.size();i++)
arr[i]=list.get(i);
IntStream is = IntStream.of(arr);
is.forEach(t->System.out.print(t+"\t"));
System.out.println();
//求和
int sum=IntStream.of(arr).sum();
System.out.println(sum);
//求平均值
double avg=IntStream.of(arr).average().getAsDouble();
System.out.println(avg);
//统计元素个数
long count=IntStream.of(arr).count();
System.out.println(count);
//获取最大值
int max=IntStream.of(arr).max().getAsInt();
System.out.println(max);
//获取最小值
int min=IntStream.of(arr).min().getAsInt();
System.out.println(min);

List<Integer> nums = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
IntSummaryStatistics stats = nums.stream().mapToInt((x) ->
x).summaryStatistics();
System.out.println("最大值："+stats.getMax());
System.out.println("最小值:"+stats.getMin());
System.out.println("所有数据之和:"+stats.getSum());
System.out.println("所有数据的平均值："+stats.getAverage());
System.out.println("所有数据的个数："+stats.getCount());

reduce归并

reduce方法用于将流种的元素进行进一步的对并计算

List<Integer> nums = Arrays.asList(13, 2, 2, 3, 7, 3, 5);
// 求和
Integer sum = nums.stream().reduce((x, y) -> x + y).get();
System.out.println(sum);
// 简化写法

Integer sum1 = nums.stream().reduce(Integer::sum).get();
System.out.println(sum1);
// 可以指定初始值的求和计算,参数1就是累加器的初始值
Integer sum2 = nums.stream().reduce(10, Integer::sum);
System.out.println(sum2);
// 对元素的长度进行求和
int sum3 =
nums.stream().map(Object::toString).mapToInt(String::length).sum();
System.out.println(sum3);
// 复杂的写法
int sum4 = nums.stream().reduce(0, (total, y) -> total +
y.toString().length(), (t1, t2) -> t1 + t2);
System.out.println(sum4);

收集结果

当数据经过souce–transform–sink处理后进行处理结果的收集。一般使用Collectors提供的常见的收集器

集合

//将处理结果存储到一个List中
Random r = new Random();
List<Integer> intList =
r.ints().limit(10).mapToObj(Integer::valueOf).collect(Collectors.toList());
System.out.println(intList);
//将处理结果存储到一个Set中
Set<Integer> intSet =
r.ints().limit(10).mapToObj(Integer::valueOf).collect(Collectors.toSet());
System.out.println(intSet);

字符串

将stream中的字符串连接并收集起来，可以在元素之间添加指定符号

Random r = new Random();
//将字符串类型的stream使用特定符号进行拼接，拼接为一个字符串
String res=r.ints().limit(10).mapToObj((x)-
>""+x).collect(Collectors.joining(","));

Map集合

可以使用Collectors.toMap方法将集合中的元素收集到Map中，但是要求有2个参数，分别用来生成Map中的key值和value值

List<Person> list = new ArrayList<>();
Random r = new Random();
for (int i = 0; i < 10; i++) {
Person p = new Person();
p.setId(i + 1L);
p.setName("name-" + i);
p.setAge(r.nextInt(8) + 14);
list.add(p);
}
//以对象的id值作为key，存储的value为name属性值
Map<Long, String> map1 =
list.stream().collect(Collectors.toMap(Person::getId, Person::getName));
System.out.println(map1);
// Function.identity()用于获取实际的对象
Map<Long, Person> map2 =
list.stream().collect(Collectors.toMap(Person::getId, Function.identity()));
System.out.println(map2);

分组操作

按照年龄分组操作

List<Person> list = new ArrayList<>();
Random r = new Random();
for (int i = 0; i < 10; i++) {
Person p = new Person();
p.setId(i + 1L);
p.setName("name-" + i);
p.setAge(r.nextInt(8) + 14);
list.add(p);
}
Map<Integer, List<Person>> map1 =
list.stream().collect(Collectors.groupingBy(Person::getAge));
System.out.println(map1);

当分组条件是一个返回boolean值的函数时，流元素可以分为2组列表，一个是返回true的元素集合，一个是返回false的元素集合

List<Person> list = new ArrayList<>();
Random r = new Random();
for (int i = 0; i < 10; i++) {
Person p = new Person();
p.setId(i + 1L);
p.setName("name-" + i);
p.setAge(r.nextInt(8) + 14);
list.add(p);
}
//将大于20岁的人分为一组，将不大于20岁的人分为一组
Map<Boolean, List<Person>> map1 =
list.stream().collect(Collectors.partitioningBy(p -> p.getAge() > 20));
System.out.println(map1);

并行流中的问题

stream使并行计算比较容易，在数据量较大的集合中可以体现出并行流的优势，利用多核CPU资源提升执行效率。但是使用需要注意一些问题。
首先必须是并行流。parallel方法可以将任意的串行流转换为并行流。

Stream.of(1, 2, 3, 5, 6, 7).forEach(System.out::println);
System.out.println();
//将一个串行流转换为并行流
Stream.of(1, 2, 3, 5, 6, 7).parallel().forEach(System.out::println);

其次要确保传递给并行流的操作函数是线程安全的

int[] bb = new int[10];
Stream.of(1, 2, 2, 5, 2, 7).parallel().forEach(s -> {
if (s < 5)bb[s]++;
});
System.out.println(Arrays.toString(bb));

转换结构

转换为数组

Object[] arr = Stream.of(1, 2, 2, 5, 2, 7).toArray();
System.out.println(Arrays.toString(arr));
Integer[] arr2 = Stream.of(1, 2, 2, 5, 2, 7).toArray(Integer[]::new);
System.out.println(Arrays.toString(arr));

转换为集合

List<Integer> list = Stream.of(1, 2, 2, 5, 2,
7).collect(Collectors.toList());
System.out.println(list);
ArrayList<Integer> list2 = Stream.of(1, 2, 3, 4,
5).collect(Collectors.toCollection(ArrayList::new));
System.out.println(list2);
Set<Integer> set1 = Stream.of(1, 2, 2, 4, 2, 5).collect(Collectors.toSet());
System.out.println(set1);
Stack<Integer> stack = Stream.of(1, 2, 2, 4, 2,
5).collect(Collectors.toCollection(Stack::new));
System.out.println(stack);

转化为string

String res = Stream.of("1", "2", "2", "5", "2",
"7").collect(Collectors.joining());
System.out.println(res);