1 redis缓存中存放的dto属性中存在LocalDateTime类型的 可以使用@JSONField注解，标注序列化和反序列话的类型；这样在获取的时候就不会报错，直接存取不需要转化操作date；类似如下：
@JSONField(serializeUsing = LocalDateTime.class, deserializeUsing = LocalDateTime.class)
private LocalDateTime createTime;
2 去重方式 List<Object>
方式一：
filter(distinctByKey(Users::getId))
public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
ConcurrentHashMap<Object, Boolean> map = new ConcurrentHashMap<>(16);
/**
* 如果不存在设置true将返回null
* 如果存在 不设置 返回 当前的value
*/
return t -> map.putIfAbsent(keyExtractor.apply(t),Boolean.TRUE) == null;
}
方式二：
collectingAndThen(toCollection(() -> new TreeSet<>(comparing(Users::getId))), ArrayList::new)
可以查看网上资料比较多
具体代码
这种方式可以多属性去重 在TreeSet<>(comparing(Users::getId+Users::getNasme))类似这种
public void collectingAndThenUniq() {
/**
* toCollection
*
* Collection<T>
*
* 把流中所有元素收集到给定的供应源创建的集合中
*
* 示例:ArrayList<Menu> menus=Menu.getMenus.stream().collect(Collectors.toCollection(ArrayList::new))
*
* collectingAndThen
*
* 转换函数返回的类型
*
* 包裹另一个转换器,对其结果应用转换函数
*
* 示例:Int count=Menu.getMenus.stream().collect(collectingAndThen(toList(),List::size))
*
*
* // TreeSet中的元素，如果是实体，必须得传比较器(或者实体类需要实现Comparable中的compareTo方法)，不然就会报错
* // TreeSet是Set的子类，里面的元素有序且不能重复，可以去重
*
* Collectors.toCollection方法：将结果收集到其它类型的集合中(这里是TreeSet)
*Collectors.collectingAndThen(
* Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(userOrder -> userOrder.getPhotographerName() + userOrder.getDeviceCode()))),
* ArrayList::new
* )
* 测试Collectors.collectingAndThen方法：将流中的数据通过Collector计算，计算的结果再通过Function处理一下
* (这里是将TreeSet转为ArrayList。即相当于将最终结果又经过了new ArrayList<>(treeSet))
*/
ArrayList<Users> collect = addModel().stream().collect(
collectingAndThen(toCollection(() -> new TreeSet<>(comparing(Users::getId))), ArrayList::new));
System.out.println("===========" + JSON.toJSONString(collect));
}
public void distictUniq() {
List<Users> collect = addModel().stream().filter(distinctByKey(Users::getId)).collect(Collectors.toList());
System.out.println("======" + JSON.toJSONString(collect));
}
乱入的排序方法
public void sort() {
List<Users> collect = addModel().stream().sorted(
comparing(Users::getCreateTime).thenComparing(Users::getId).reversed()).collect(Collectors.toList());
List<Long> collect1 = addModel().stream().sorted(
comparing(Users::getCreateTime).thenComparing(Users::getId).reversed()).map(Users::getId).collect(
Collectors.toList());
System.out.println("========sort" + JSON.toJSONString(collect) + " ==== ===" + JSON.toJSONString(collect1));
}
这种方式复用性强
public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
ConcurrentHashMap<Object, Boolean> map = new ConcurrentHashMap<>(16);
/**
* 如果不存在设置true将返回null
* 如果存在 不设置 返回 当前的value
*/
return t -> map.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
}
