1.lambda去重
public static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) {
Map<Object, Boolean> seen = new ConcurrentHashMap<>();
return object -> seen.putIfAbsent(keyExtractor.apply(object), Boolean.TRUE) == null;
}
//对工号重复的进行去重
ens=ens.stream().filter(distinctByKey(i->{
return i.get("code");
})).collect(Collectors.toList());
2.lambda对map排序
package com.example;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.core.annotation.Order;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.*;
import java.util.stream.Collectors;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UeditorTestApplicationTests {
@Test
public void contextLoads() {
Map<String,Object> map = new HashMap<>();
map.put("1","oo1");
map.put("2","oo1");
map.put("3","oo1");
Map<String,Object> map1 = new HashMap<>();
map1.put("1","oo1");
map1.put("2","oo2");
map1.put("3","oo2");
Map<String,Object> map2 = new HashMap<>();
map2.put("1","oo2");
map2.put("2","oo1");
map2.put("3","oo1");
List<Map> list = new ArrayList<>();
list.add(map);
list.add(map1);
list.add(map2);
// ArrayList<Map> collect = list.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() ->
// new TreeSet<>(Comparator.comparing(o -> (String) o.get("1")))), ArrayList::new));
//
// System.out.println(collect);
// ArrayList<Map> collect1 = list.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() ->
// new TreeSet<>((o1, o2) -> {
// String i = (String) o1.get("2");
// String j = (String) o2.get("2");
// return i.compareTo(j);
// })), ArrayList::new));
//
// System.out.println(collect1);
TreeSet<Map<String,Object>> t = new TreeSet<>((o1, o2) -> {
String i = (String) o1.get("2");
String j = (String) o2.get("2");
return i.compareTo(j);
});
t.add(map);
t.add(map1);
t.add(map2);
System.out.println(t);
}
class A {
}
class B implements Comparable {
@Override
public int compareTo(Object o) {
return 0;
}
}
}
3.lambda对List<Map>排序
list=list.stream().sorted(Comparator.comparing(m -> m.get("排序的字段").toString())).collect(Collectors.toList());
//按日期排序
transferList = transferList.stream().sorted((d1, d2) -> {
if(d1.get("inTime")!=null&& d2.get("inTime")!=null){
Date date1 = DateUtils.parse((String) d1.get("inTime"), DateUtils.DATE_FORMAT_YYYY_MM_DD_HH_MM_SS);
Date date2 = DateUtils.parse((String) d2.get("inTime"), DateUtils.DATE_FORMAT_YYYY_MM_DD_HH_MM_SS);
return date1.compareTo(date2);
}
return 0;
}).collect(Collectors.toList());
4.lambda操作map根据key或者value排序，reversed()是倒序，正序就去掉.reversed()
public static <K extends Comparable<? super K>, V > Map<K, V> sortByKey(Map<K, V> map) {
Map<K, V> result = new LinkedHashMap<>();
map.entrySet().stream()
.sorted(Map.Entry.<K, V>comparingByKey()
.reversed()).forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
return result;
}
public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue(Map<K, V> map) {
Map<K, V> result = new LinkedHashMap<>();
map.entrySet().stream()
.sorted(Map.Entry.<K, V>comparingByValue()
.reversed()).forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
return result;
}
5.按半小时统计结果值
public static void main(String[] args)throws Exception {
List<Chart> charts=new ArrayList<>();
SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
charts.add(new Chart(format.parse("2020-01-01 01:10:00"),2d));
charts.add(new Chart(format.parse("2020-01-01 01:20:00"),3d));
charts.add(new Chart(format.parse("2020-01-01 01:40:00"),4d));
charts.add(new Chart(format.parse("2020-02-01 01:50:00"),3d));
charts.add(new Chart(format.parse("2020-01-01 02:20:00"),26d));
Map<Long, Chart> collect = charts.stream().collect(Collectors.toMap(chart -> {
System.out.println(chart.date.getTime()/(30*60*1000));
return chart.date.getTime()/(30*60*1000);
}, Function.identity(), (k1, k2) -> {
return k1.date.getTime() > k2.date.getTime() ? k1 : k2;
}));
Map<String, Double> map=new HashMap<>();
format = new SimpleDateFormat("yyyy-MM-dd");
SimpleDateFormat finalFormat = format;
collect.forEach((k, v)->{
//此处把v.date转换为半小时的标准格式
String format1 = finalFormat.format(v.date);
String hours = v.date.getHours()+"";
int minutes = v.date.getMinutes();
if (minutes>=0&&minutes<30){
hours=format1+" "+hours+":00";
}else {
hours=format1+" "+hours+":30";
}
map.put(hours,v.value);
});
Map<String, Double> stringDoubleMap = sortByKey(map);
System.out.println(stringDoubleMap);
}
public static <K extends Comparable<? super K>, V > Map<K, V> sortByKey(Map<K, V> map) {
Map<K, V> result = new LinkedHashMap<>();
map.entrySet().stream()
.sorted(Map.Entry.<K, V>comparingByKey()).forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
return result;
}
static class Chart{
public Date date;
public Double value;
public Chart(Date date, Double value) {
this.date = date;
this.value = value;
}
}
| 
转播
