废话不多说，直接上demo。
代码片段是直接从正常的项目里面截取的，所以从代码部分到响应结果都做了简单处理，但不影响正常的阅读。
ArrayList<Object> fixedNodeList = new ArrayList<>();
//固定节日
QueryWrapper<NodeInfo> fixedNodeInfo = new QueryWrapper<>();
List<NodeInfo> fixedNodeInfos = nodeInfoMapper.selectList(fixedNodeInfo);
HashMap<String, String> fixedNodeMap = new HashMap<>();
fixedNodeInfos.forEach((fixedNode)-> {
if (ObjectUtil.isNotEmpty(fixedNode.getNodeName())) {
//拿到每一个节日名称和对应的活动截止时间
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String targetTime = simpleDateFormat.format(fixedNode.getEventTime()); //活动截止时间
String thisTime = simpleDateFormat.format(System.currentTimeMillis()); //当前系统时间
//计算节日倒计时
String countDown = CountDownUtils.getCountDown(targetTime, thisTime);
//取出节日名称和倒计时天数
fixedNodeMap.put(fixedNode.getNodeName(),countDown);
} else {
fixedNodeMap.put("非法的节点！", "-999");
}
});
//按照倒计时日期升序排列
Map<String, String> fixedNodeMaps = MapSortUtil.sortByValueAsc(fixedNodeMap);
//从排序完成的结果集
fixedNodeMaps.forEach((name,num)->{
//拿到每一个节日名称和对应的倒计时天数
fixedNodeList.add(ImmutableMap.of(
"nodeName",ObjectUtil.defaultIfNull(name,0),
"countDown",ObjectUtil.defaultIfNull(num,0)
));
});
//数据汇总
List list = Stream.of(
ImmutableMap.of("固定节日",ObjectUtil.defaultIfNull(fixedNodeList,0))
).collect(Collectors.toList());请求接口返回示例：
{
"code": 200,
"msg": "操作成功",
"data": [
{
"固定节日": [
{
"nodeName": "国庆节",
"countDown": "185"
},
{
"nodeName": "元旦节",
"countDown": "276"
},
{
"nodeName": "龙抬头",
"countDown": "308"
}
]
}
]
}附上对应的工具类：
CountDownUtils
package com.demo.util;
import java.text.SimpleDateFormat;
/**
* @Author zf
* @Description Java 倒计时工具类（由秒计算天、小时、分钟、秒.）
* @ClassName CountDownUtils.java
* @ProjectName Demo
*/
public class CountDownUtils {
private static long day = 0;
private static long hour = 0;
private static long minute = 0;
private static long second = 0;
private static boolean dayNotAlready = false;
private static boolean hourNotAlready = false;
private static boolean minuteNotAlready = false;
private static boolean secondNotAlready = false;
/**
* @Description 根据目标时间计算倒计时 天:小时:分钟:秒
* @Param [overTime(目标时间),currentDateTime(当前时间或指定时间)]
* @return void
**/
public static String getCountDown(String overTime, String currentDateTime) {
Long totalSeconds = getTimeDiffSecond(overTime,currentDateTime);
resetData();
if (totalSeconds > 0) {
secondNotAlready = true;
second = totalSeconds;
if (second >= 60) {
minuteNotAlready = true;
minute = second / 60;
second = second % 60;
if (minute >= 60) {
hourNotAlready = true;
hour = minute / 60;
minute = minute % 60;
if (hour > 24) {
dayNotAlready = true;
day = hour / 24;
hour = hour % 24;
}
}
}
}
// return day + ":" + hour + ":" + minute+ ":" + second;
return String.valueOf(day); // 这里根据项目需要只返回天数
}
private static void resetData() {
day = 0;
hour = 0;
minute = 0;
second = 0;
dayNotAlready = false;
hourNotAlready = false;
minuteNotAlready = false;
secondNotAlready = false;
}
/**
* @Description 获取两个时间的秒时差 date1 - date2
* @Param [date1, date2]
* @return long
**/
public static long getTimeDiffSecond(String date1, String date2) {
if (date1 == null || date1.equals(""))
return 0;
if (date2 == null || date2.equals(""))
return 0;
// 转换为标准时间
SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
java.util.Date date = null;
java.util.Date mydate = null;
try {
date = myFormatter.parse(date1);
mydate = myFormatter.parse(date2);
} catch (Exception e) {
e.printStackTrace();
}
long day = (date.getTime() - mydate.getTime()) / 1000;
return day;
}
}MapSortUtil
package com.demo.util;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.stream.Collectors;
/**
* Map排序工具类
* Author zf
* @ClassName MapSortUtil.java
* @ProjectName Demo
*/
public class MapSortUtil {
private static Comparator<Map.Entry> comparatorByKeyAsc = (Map.Entry o1, Map.Entry o2) -> {
if (o1.getKey() instanceof Comparable) {
return ((Comparable) o1.getKey()).compareTo(o2.getKey());
}
throw new UnsupportedOperationException("键的类型尚未实现Comparable接口");
};
private static Comparator<Map.Entry> comparatorByKeyDesc = (Map.Entry o1, Map.Entry o2) -> {
if (o1.getKey() instanceof Comparable) {
return ((Comparable) o2.getKey()).compareTo(o1.getKey());
}
throw new UnsupportedOperationException("键的类型尚未实现Comparable接口");
};
private static Comparator<Map.Entry> comparatorByValueAsc = (Map.Entry o1, Map.Entry o2) -> {
if (o1.getValue() instanceof Comparable) {
return ((Comparable) o1.getValue()).compareTo(o2.getValue());
}
throw new UnsupportedOperationException("值的类型尚未实现Comparable接口");
};
private static Comparator<Map.Entry> comparatorByValueDesc = (Map.Entry o1, Map.Entry o2) -> {
if (o1.getValue() instanceof Comparable) {
return ((Comparable) o2.getValue()).compareTo(o1.getValue());
}
throw new UnsupportedOperationException("值的类型尚未实现Comparable接口");
};
/**
* 按键升序排列
*/
public static <K, V> Map<K, V> sortByKeyAsc(Map<K, V> originMap) {
if (originMap == null) {
return null;
}
return sort(originMap, comparatorByKeyAsc);
}
/**
* 按键降序排列
*/
public static <K, V> Map<K, V> sortByKeyDesc(Map<K, V> originMap) {
if (originMap == null) {
return null;
}
return sort(originMap, comparatorByKeyDesc);
}
/**
* 按值升序排列
*/
public static <K, V> Map<K, V> sortByValueAsc(Map<K, V> originMap) {
if (originMap == null) {
return null;
}
return sort(originMap, comparatorByValueAsc);
}
/**
* 按值降序排列
*/
public static <K, V> Map<K, V> sortByValueDesc(Map<K, V> originMap) {
if (originMap == null) {
return null;
}
return sort(originMap, comparatorByValueDesc);
}
private static <K, V> Map<K, V> sort(Map<K, V> originMap, Comparator<Map.Entry> comparator) {
return originMap.entrySet()
.stream()
.sorted(comparator)
.collect(
Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2,
LinkedHashMap::new));
}
}