java8 统计_java8 list统计（Stream API ）

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);