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

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

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

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

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

static class User{
    String id;
    String name;
    public String getId() {
      return id;
    }
    public void setId(String id) {
      this.id=id;
    }
    public String getName() {
      return name;
    }
    public void setName(String name) {
      this.name = name;
    }
  }
  public static void main(String[] args) throws Exception {
    List<User> distinctList = new ArrayList();
    User user1 = new User();
    user1.setId("1");
    user1.setName("11");
    distinctList.add(user1);
    User user2 = new User();
    user2.setId("2");
    user2.setName("21");
    distinctList.add(user2);
    User user3 = new User();
    //user3.setId("3");
    user3.setName("31");
    distinctList.add(user3);
    User user4 = new User();
    //user4.setId("4");
    user4.setName("31");
    distinctList.add(user4);
    //list是需要去重的list，返回值是去重后的list
    List<User> res = distinctList.stream().collect(
        Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(o -> {
          if (StringUtils.isNotBlank(o.getId())) {
            return o.getName();
          }
          return o.getName();
        }))), ArrayList::new));
    //筛选
    List<User> users=distinctList.stream().collect(Collectors.toMap(key->key.getName(),value->value,(v1,v2)->{
      if(v1.getId()!=null){
        return v1;
      }else if(v2.getId()!=null){
        return v2;
      }
      return v1;
    })).values().stream().collect(Collectors.toList());
    //res = distinctList.stream().filter(ls->ls.getId().equals("222")).collect(Collectors.toList());
    System.out.println(users);
  }

Optional<Person> max = personList.stream().max(Comparator.comparing(Person::getCreateDate));
Person person= max.get();