JAVA日期处理工具类-DateUtil_dateutil java

如下未特别说明, 均指jdk1.8实现版本.

功能列表:

1. 解决多线程下使用SimpleDateFormat(非线程安全类), 导致的如下问题:
   java.lang.NumberFormatException: multiple points
2. 多线程环境下,将 dateStr 转化为 Date 形式.
3. 多线程环境下,将 dateTimeStr 转化为 Date 形式.
4. 对象转为JSON字符串, 序列化格式由自己自定义指定(如: 空list,空string,null数字,null布尔值,nullMap).
5. 根据步长(step)来向前或向后获取某一天的日期字符串(date形式).
6. 根据步长(step)来向前或向后获取某一天的日期字符串(datetime形式).
7. 根据给定参照日期(baseDate), 和步长(step)来向前或向后获取某一天的日期字符串(datetime形式).
8. 字符串转Long类型.
9. 根据指定的如下格式的字符串, 格式化为Date类型.
   private static final String DATE_FORMAT = “yyyy-MM-dd”;
   private static final String DATETIME_FORMAT = “yyyy-MM-dd HH:mm:ss”;
10. 判断某一年份是否闰年.
11. 根据步长返回N年前或N年后的年份数字.
12. 根据步长返回N年前或N年后的年份数字.
13. JDK8之前版本: 获取当前时间的整点时刻.
14. JDK8中 : 获取当前时间的整点时刻.
15. 通过如下枚举类型
    * ①: LOCAL_DATE 获取当日日期 : 格式为 “yyyy-MM-dd”
    * ②: LOCAL_DATETIME 获取当日整点时间: 格式为 “yyyy-MM-dd HH:00:00”.
16. 获取两个日期间隔的所有日期.

MyDateUtils.java代码清单:

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import lombok.extern.slf4j.Slf4j;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.stream.Stream;

/**
 * User: DavidTest
 * Date: 
 * Time: 
 * Desc: Java日期处理工具类
 */
@Slf4j
public class MyDateUtils {

    private static DateTimeFormatter DTF = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    private static DateTimeFormatter DTF_OF_TIME = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    private static final String DATE_FORMAT = "yyyy-MM-dd";
    private static final String DATETIME_FORMAT = "yyyy-MM-dd HH:mm:ss";

    //对于每一个( Date | Datetime ) 类型的线程
    private static final ThreadLocal<SimpleDateFormat> THREAD_LOCAL_SDF = new ThreadLocal<>();

    //日期类型枚举:①:LOCAL_DATE,格式 "yyyy-MM-dd" ;②:LOCAL_DATETIME,格式: "yyyy-MM-dd HH:mm:ss".
    public enum MY_DATE_TYPE {
        LOCAL_DATE, LOCAL_DATETIME
    }

    /**
     * 多线程环境下,将 dateStr 转化为 Date 形式.
     * 避免多线程下使用不安全的 SimpleDateFormat,
     * 抛出: java.lang.NumberFormatException: multiple points 异常.
     *
     * @param dateStr
     * @return
     */
    public static Date parseBySDF(String dateStr) throws ParseException {
        SimpleDateFormat sdf = THREAD_LOCAL_SDF.get();
        if (sdf == null) {
            sdf = new SimpleDateFormat(DATE_FORMAT);
        }

        log.info(">>>> 当前线程为: " + Thread.currentThread().getName());
        Date date = sdf.parse(dateStr);

        return date;
    }

    /**
     * 多线程环境下,将 dateTimeStr 转化为 Date 形式.
     * 避免多线程下使用不安全的 SimpleDateFormat,
     * 抛出: java.lang.NumberFormatException: multiple points 异常.
     *
     * @param dateTimeStr
     * @return
     */
    public static Date parseBySDFLong(String dateTimeStr) throws ParseException {
        SimpleDateFormat sdfLong = THREAD_LOCAL_SDF.get();
        if (sdfLong == null) {
            sdfLong = new SimpleDateFormat(DATETIME_FORMAT);
        }

        log.info(">>>> 当前线程为: " + Thread.currentThread().getName());
        Date date = sdfLong.parse(dateTimeStr);

        return date;
    }

    public static String toJSONStr(Object obj) {
        String msg = JSON.toJSONString(obj,
                SerializerFeature.WriteNullListAsEmpty,
                SerializerFeature.WriteNullStringAsEmpty,
                SerializerFeature.WriteNullNumberAsZero,
                SerializerFeature.WriteNullBooleanAsFalse,
                SerializerFeature.WriteMapNullValue);
        return msg;
    }

    public static String getDate(Long daysToAdd) {
        LocalDate daysBefore = LocalDate.now().plusDays(daysToAdd);
        return daysBefore.format(DTF);
    }

    public static String getDateTime(Long daysToAdd) {
        LocalDateTime daysBefore = LocalDateTime.now().plusDays(daysToAdd);
        return daysBefore.format(DTF_OF_TIME);
    }

    public static String getDate(String baseDate, Long daysToAdd) {
        LocalDate daysBefore = LocalDate.parse(baseDate).plusDays(daysToAdd);
        return daysBefore.format(DTF);
    }

    public static Long getLong(String x) {
        Long r = null;

        try {
            r = new Long(x.trim());
        } catch (NumberFormatException e) {
            log.error("", e);
        }

        return r;
    }

    public static Date getDate(String dateStr) {
        try {
            return new SimpleDateFormat(DATE_FORMAT).parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static String getDateStr(Date date) {
        return new SimpleDateFormat(DATETIME_FORMAT).format(date);
    }

    /**
     * 判断某一年份是否闰年
     *
     * @param year
     * @return
     */
    public static Boolean isLeapYear(Integer year) {
        if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 根据步长返回N年前或N年后的年份数字
     *
     * @param step
     * @return
     */
    public static Integer getSpecificYearByStep(Integer step) {
        LocalDate localDate = LocalDate.now();
        return localDate.plusYears(step).getYear();
    }

    /**
     * 根据步长返回N年前或N年后的年份数字
     *
     * @param baseDateTime 日期时间格式, 如"2020-04-20 00:00:00"
     * @param step         向前后向后的时间间隔,由正负值确定是向前或向后变更小时数(如 step=1, 表示"2020-04-20 01:00:00
     * @return
     */
    public static String getSpecificDateHourByStep(String baseDateTime, Integer step) {
        if (baseDateTime != null && 19 == baseDateTime.length()) {
            LocalDateTime localDate = LocalDateTime.parse(baseDateTime, DTF_OF_TIME);
            return localDate.plusHours(step).format(DTF_OF_TIME);
        } else {
            throw new RuntimeException("Parameter baseDateTime's formatter invalid, please check!");
        }
    }

    /**
     * 获取2个日期之间相差的天数.
     * 如果:
     *      1: localDate1 > localDate2, 值为正.
     *      2: localDate1 < localDate2, 值为负.
     *
     * @param localDate1 起始日
     * @param localDate2 终止日
     * @return
     */
    public static Integer getPeriodDays(LocalDate localDate1, LocalDate localDate2) {
        return (int) (localDate1.toEpochDay() - localDate2.toEpochDay());
    }

    /**
     * JDK8之前: 获取当前时间的整点时刻
     *
     * @return
     */
    public static Date getCurrentHourTimeBeforeJDK8() {
        Calendar ca = Calendar.getInstance();
        ca.set(Calendar.MINUTE, 0);
        ca.set(Calendar.SECOND, 0);
        ca.set(Calendar.MILLISECOND, 0);

        return ca.getTime();
    }

    /**
     * JDK8中  : 获取当前时间的整点时刻
     *
     * 如下两种实现方式都可以.
     * @return
     */
    public static Date getCurrentHourTimeOfJDK8() {
        LocalDateTime time = LocalDateTime.now();

        return  Date.from(time.minusMinutes(time.getMinute()).minusSeconds(time.getSecond()).atZone(ZoneId.systemDefault()).toInstant());
        //return  Date.from(time.withMinute(0).withSecond(0).atZone(ZoneId.systemDefault()).toInstant());
    }

    /**
     * 通过如下枚举类型
     *  ①: LOCAL_DATE     获取当日日期    : 格式为 "yyyy-MM-dd"
     *  ②: LOCAL_DATETIME 获取当日整点时间: 格式为 "yyyy-MM-dd HH:00:00"
     *
     * @return
     */
    public static String getCurrentDateOrTimeByType(MY_DATE_TYPE date_type) {
        LocalDateTime time = LocalDateTime.now();
        switch (date_type) {
            case LOCAL_DATE:
                return (time.withMinute(0).withSecond(0).withNano(0)).format(DTF);
            case LOCAL_DATETIME:
                return (time.withMinute(0).withSecond(0).withNano(0)).format(DTF_OF_TIME);
            default:
                return null;
        }
    }

    /**
     * 获取两个日期间隔的所有日期
     *
     * @param start 格式必须为'2019-01-01'
     * @param end   格式必须为'2019-02-01'
     * @return
     */
    public static List<String> getBetweenDate(String start, String end) {
        List<String> list = new ArrayList<>();
        LocalDate startDate = LocalDate.parse(start);
        LocalDate endDate = LocalDate.parse(end);

        long distance = ChronoUnit.DAYS.between(startDate, endDate);
        System.out.println("distance = " + distance);
        Stream.iterate(startDate, localDate -> localDate.plusDays(1))
                .limit(distance + 1)
                .forEach(f -> {
                    list.add(f.toString());
                });
        return list;
    }

    public static void main(String[] args) {
//        System.out.println(getSpecificYearByStep(-1));
//        System.out.println(MyDateUtils.getSpecificYearByStep(0));
//        System.out.println(MyDateUtils.getDate("2020-02-29", -366L));
//        System.out.println(MyDateUtils.getDate("2019-01-01", 0L));
//        System.out.println(MyDateUtils.getDate("2020-02-28", -365L));
//        System.out.println(MyDateUtils.getDateTime(0L));

//        System.out.println(getCurrentDateOrTimeByType(MY_DATE_TYPE.LOCAL_DATE));
//        System.out.println(getCurrentDateOrTimeByType(MY_DATE_TYPE.LOCAL_DATETIME));

//        System.out.println((int)((double)297/54*2));

        System.out.println(getBetweenDate("2019-05-01", "2020-05-20").size());

        System.out.println(getSpecificDateHourByStep("2020-05-21 00:00:00", -1));

    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274