使用lambda去重、map排序、按任意时间间隔（小时、半小时、分钟）进行结果统计

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

6.lambda去重，支持根据条件有选择进行过滤去重

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


	}

7.Java一个集合中根据，获取某一个日期对象最大值得对象

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

8.将list切分为等长的子集

List<List<D460100aParam.Input.Data.SellInfo>> partitionedList =
					IntStream.range(0, (mapList.size() + 99) / 100)
							.mapToObj(i -> mapList.subList(i * 100, Math.min((i + 1) * 100, mapList.size())))
							.collect(Collectors.toList());