lambda表达式使用记录

lambda表达式使用记录

把集合装成流，可以多次使用这个集合，但是不转换流的话，只能用一次
stream() ： 为集合创建串行流。
parallelStream() ： 为集合创建并行流（把一个内容分成多个数据块，用不同的线程分别处理每个数据块的流）。

从对象集合中将某一字段组合成新的集合

List<TagEntity> data = xxx;
List<Integer> userIds = data.stream().map(e -> e.getId()).collect(Collectors.toList());

将 List< TagEntity >转为Map

List<TagEntity> data = xxx;
//key相同时会报错，需加，(p1, p2) -> p1)
Map<String, TagEntity> tagEMap = data.parallelStream().collect(Collectors.toMap(TagEntity::getTag, TagEntity -> TagEntity, (p1, p2) -> p1));

//如果value为null,会报空指针异常,需加Optional.ofNullable(TagEntity.getName()).orElse("")
Map<String, String> tagMap = data.stream().collect(Collectors.toMap(TagEntity::getTag, TagEntity -> Optional.ofNullable(TagEntity.getName()).orElse(""), (p1, p2) -> p1));

// 将List<TagEntity>转为Map<String,Map<Integer,Long>>

将 List< Map >转为Map

List<Map> data = xxx;
Map<String, Map> collectE0 = data.stream().collect(Collectors.toMap(Map -> (String) Map.get("tag"), Map -> Map, (p1, p2) -> p1));

分组

// 根据单个字段分组
Map<Integer, List<Student>> map= list.stream().collect(Collectors.groupingBy(Student::getAge));

// 根据单个字段分组,处理key
Map<Long, List<Student>> map= list.stream().collect(Collectors.groupingBy(e->Long.valueof(e.getSize()+"")));

// 拼接key分组
Map<String, List<Student>> map= list.stream().collect(Collectors.groupingBy( e -> e.getAge() + "_" + e.getName()));

将 List< Map >转为 Map<Integer, Map<String,Long>>

Map<Integer, Map<String,Long>> map= list.stream().collect(Collectors.groupingBy(Student::getAge,HashMap::new,Collectors.toMap(Student::getName,Student::getNum)));

过滤

//过滤出符合条件的数据
List<Student> filterList = list.stream().filter(e -> e.getName().equals("小明")).collect(Collectors.toList());

排序

List< String >排序

// 正序
list.sort((a,b) -> a.compareTo(b));
// 倒序
ist.sort((a,b) -> a.compareTo(b));
list.sort(Comparator.reverseOrder());

List<对象>排序

//顺序
Collections.sort(studentList, Comparator.comparing(Student::getName));
studentList.sort(Comparator.comparing(Student::getName));
//倒序
studentList.sort(Comparator.comparing(Student::getName).reversed());

List< Map >排序

需排序的字段为 int 时

// 顺序
List<Map> listMap = list.stream().sorted((i, j) -> i.get("time") - j.get("time")).collect(Collectors.toList());
// 倒序
List<Map> listMap = list.stream().sorted((i, j) -> j.get("time") - i.get("time")).collect(Collectors.toList());

根据不同条件排序

// 根据年龄倒序，年龄相同时，按照名称倒序
List<Map> listMap = list.stream().sorted((i,j)->{
	if (i.get("age").equals(j.get("age").toString())) {
		return j.get("name").toString().compareTo(i.get("name").toString());
	}else {
		return j.get("age").toString().compareTo(i.get("age").toString();
	}
}).collect(Collectors.toList());

Map排序

按key排序

// 顺序
Map result = map.entrySet().stream().sorted(Map.Entry.<K, V>.comparingByKey())
                .forEachOrdered(x -> result2.put(x.getKey(), x.getValue()));
// 倒序
Map result = map.entrySet().stream().sorted(Map.Entry.<K, V>.comparingByKey().reversed())
                .forEachOrdered(x -> result2.put(x.getKey(), x.getValue()));

按Vaule排序

// 顺序
 Map result = map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByValue())
            .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
// 倒序
 Map result = map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByValue().reversed())
            .forEach(e -> result.put(e.getKey(), e.getValue()));

计算

单个计算

List< Double > 数值

//最大
double maxDish = list1.stream().max(Comparator.comparingDouble(e->e)).get());
//最小
double  minDish = list1.stream().min(Comparator.comparingDouble(e->e)).get());
//平均
Double avgVal = list.stream().collect(Collectors.averagingDouble(e->e)).get())

List< Student > 对象

//最大
Optional<Student> maxOp = list.stream().max(Comparator.comparingInt(Student::getValue));
//最小
Optional<Student> minOp = list.stream().min(Comparator.comparingInt(Student::getValue));
//平均
Double avgVal = list.stream().collect(Collectors.averagingInt(Student::getValue))

批量计算

// int值 计算
//IntSummaryStatistics summaryStatistics = list1.stream().collect(Collectors.summarizingInt(Student::getValue));
// double值 计算
DoubleSummaryStatistics summaryStatistics = list1.stream().collect(Collectors.summarizingDouble(Student::getValue));
double average = summaryStatistics.getAverage();
long count = summaryStatistics.getCount();
double max = summaryStatistics.getMax();
double min = summaryStatistics.getMin();
long sum = summaryStatistics.getSum();