时间转换工具

于 2020-10-22 18:02:04 发布
阅读量346 收藏 1
点赞数 1
分类专栏： java 文章标签： date LocalDateTime Long 时间转换
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouzhenyong/article/details/109227438
版权

之前写的一个时间转换工具，分享下

import java.sql.Time;
import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Pattern;

/**
 * 时间格式的各种转换
 * <p>
 *     <ul>
 *         1.LocalDateTime ----> LocalDate
 *         2.LocalDateTime ----> Long
 *         3.LocalDateTime ----> Date
 *         4.LocalDateTime ----> String
 *
 *         1.LocalDate ----> LocalDateTime
 *         2.LocalDate ----> Long
 *         3.LocalDate ----> Date
 *         4.LocalDate ----> String
 *
 *         1.Date ----> LocalDateTime
 *         2.Date ----> LocalDate
 *         3.Date ----> Long
 *         4.Date ----> String
 *
 *         1.Timestamp ----> LocalDateTime
 *         2.Timestamp ----> Long
 *         3.Timestamp ----> String
 *         4.Timestamp ----> LocalDate
 *
 *         1.String ----> LocalDateTime
 *         2.String ----> LocalDate
 *         3.String ----> Date
 *         4.String ----> Timestamp
 *         5.String ----> LocalTime
 *         6.String ----> Time
 *
 *         1.Long ----> Date
 *         2.Long ----> LocalDateTime
 *         3.Long ----> LocalDate
 *     </ul>
 * @author shizi
 * @since 2020/9/9 8:58 下午
 */
public class LocalDateTimeUtil {

    public static final String yMdHmsSSS = "yyyy-MM-dd HH:mm:ss.SSS";
    public static final String yMdHmsS = "yyyy-MM-dd HH:mm:ss.S";
    public static final String yMdHms = "yyyy-MM-dd HH:mm:ss";
    public static final String yMdHm = "yyyy-MM-dd HH:mm";
    public static final String yMdH = "yyyy-MM-dd HH";
    public static final String yMd = "yyyy-MM-dd";
    public static final String yM = "yyyy-MM";
    public static final String y = "yyyy";

    public static final String HmsSSSMore = "HH:mm:ss.SSSSSSSSS";
    public static final String HmsSSS = "HH:mm:ss.SSS";
    public static final String Hms = "HH:mm:ss";
    public static final String Hm = "HH:mm";
    public static final String H = "HH";

    private static final Pattern yMdHmsSSSPattern = Pattern.compile("^(\\d){4}-(\\d){2}-(\\d){2} (\\d){2}:(\\d){2}:(\\d){2}.(\\d){3}$");
    private static final Pattern yMdHmsSPattern = Pattern.compile("^(\\d){4}-(\\d){2}-(\\d){2} (\\d){2}:(\\d){2}:(\\d){2}.(\\d){1}$");
    private static final Pattern yMdHmsPattern = Pattern.compile("^(\\d){4}-(\\d){2}-(\\d){2} (\\d){2}:(\\d){2}:(\\d){2}$");
    private static final Pattern yMdHmPattern = Pattern.compile("^(\\d){4}-(\\d){2}-(\\d){2} (\\d){2}:(\\d){2}$");
    private static final Pattern yMdHPattern = Pattern.compile("^(\\d){4}-(\\d){2}-(\\d){2} (\\d){2}$");
    private static final Pattern yMdPattern = Pattern.compile("^(\\d){4}-(\\d){2}-(\\d){2}$");
    private static final Pattern yMPattern = Pattern.compile("^(\\d){4}-(\\d){2}$");
    private static final Pattern yPattern = Pattern.compile("^(\\d){4}$");

    private static final Map<String, SimpleDateFormat> simpleDateFormat = new ConcurrentHashMap<>(7);
    private static final Map<String, DateTimeFormatter> localDateTimeFormat = new ConcurrentHashMap<>(7);

    static {
        simpleDateFormat.put(yMdHmsSSS, new SimpleDateFormat(yMdHmsSSS));
        simpleDateFormat.put(yMdHms, new SimpleDateFormat(yMdHms));
        simpleDateFormat.put(yMdHm, new SimpleDateFormat(yMdHm));
        simpleDateFormat.put(yMdH, new SimpleDateFormat(yMdH));
        simpleDateFormat.put(yMd, new SimpleDateFormat(yMd));
        simpleDateFormat.put(yM, new SimpleDateFormat(yM));
        simpleDateFormat.put(y, new SimpleDateFormat(y));

        localDateTimeFormat.put(yMdHmsSSS, DateTimeFormatter.ofPattern(yMdHmsSSS));
        localDateTimeFormat.put(yMdHms, DateTimeFormatter.ofPattern(yMdHms));
        localDateTimeFormat.put(yMdHm, DateTimeFormatter.ofPattern(yMdHm));
        localDateTimeFormat.put(yMdH, DateTimeFormatter.ofPattern(yMdH));
        localDateTimeFormat.put(yMd, DateTimeFormatter.ofPattern(yMd));
        localDateTimeFormat.put(yM, DateTimeFormatter.ofPattern(yM));
        localDateTimeFormat.put(y, DateTimeFormatter.ofPattern(y));
    }

    /**
     * LocalDateTime 转 LocalDate
     */
    private static LocalDate localDateTimeToLocalDate(LocalDateTime localDateTime) {
        return localDateTime.toLocalDate();
    }

    /**
     * LocalDateTime 转 Long
     */
    public static Long localDateTimeToLong(LocalDateTime localDateTime) {
        return localDateTime.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
    }

    /**
     * LocalDateTime 转 Date
     */
    public static Date localDateTimeToDate(LocalDateTime localDateTime) {
        return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
    }

    /**
     * LocalDateTime 转 String
     */
    public static String localDateTimeToString(LocalDateTime localDateTime) {
        return localDateTime.format(localDateTimeFormat.get(yMdHms));
    }


    /**
     * LocalDateTime 转 String
     */
    public static String localDateTimeToString(LocalDateTime localDateTime, String dateTimeFormat) {
        return localDateTime.format(localDateTimeFormat.get(dateTimeFormat));
    }

    /**
     * LocalDateTime 转 String
     */
    public static String localDateTimeToString(LocalDateTime localDateTime, DateTimeFormatter dateTimeFormatter) {
        return localDateTime.format(dateTimeFormatter);
    }


    /**
     * LocalDate 转 LocalDateTime
     */
    public static LocalDateTime localDateToLocalDateTime(LocalDate localDate) {
        return LocalDateTime.of(localDate, LocalTime.parse("00:00:00"));
    }

    /**
     * LocalDate 转 Long
     */
    public static Long localDateToLong(LocalDate localDate) {
        return localDate.atStartOfDay(ZoneId.systemDefault()).toInstant().toEpochMilli();
    }

    /**
     * LocalDate 转 Date
     */
    public static Date localDateToDate(LocalDate localDate) {
        return Date.from(localDate.atStartOfDay().atZone(ZoneId.systemDefault()).toInstant());
    }

    /**
     * LocalDate 转 String
     */
    public static String localDateToString(LocalDate localDate) {
        return localDate.format(localDateTimeFormat.get(yMd));
    }


    /**
     * Date 转 LocalDateTime
     */
    public static LocalDateTime dateToLocalDateTime(Date date) {
        return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
    }

    /**
     * Date 转 Long
     */
    public static Long dateToLong(Date date) {
        return date.getTime();
    }

    /**
     * Date 转 LocalDate
     */
    public static LocalDate dateToLocalDate(Date date) {
        return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault()).toLocalDate();
    }

    /**
     * Date 转 String
     */
    public static String dateToString(Date date) {
        return simpleDateFormat.get(yMdHms).format(date);
    }

    /**
     * Date 转 String
     */
    public static String dateToString(Date date, SimpleDateFormat simpleDateFormat) {
        return simpleDateFormat.format(date);
    }

    /**
     * Date 转 String
     */
    public static String dateToString(Date date, String simpleDateFormatStr) {
        return simpleDateFormat.get(simpleDateFormatStr).format(date);
    }


    /**
     * Timestamp 转 LocalDateTime
     */
    public static LocalDateTime timestampToLocalDateTime(Timestamp timestamp) {
        return timestamp.toLocalDateTime();
    }

    /**
     * Timestamp 转 Long
     */
    public static Long timestampToLong(Timestamp timestamp) {
        return timestamp.getTime();
    }

    /**
     * Timestamp 转 LocalDate
     */
    public static LocalDate timestampToLocalDate(Timestamp timestamp) {
        return LocalDateTime.ofInstant(timestamp.toInstant(), ZoneId.systemDefault()).toLocalDate();
    }

    /**
     * Timestamp 转 String
     */
    public static String timestampToString(Timestamp timestamp) {
        return simpleDateFormat.get(yMdHmsSSS).format(timestamp);
    }

    /**
     * Timestamp 转 String
     */
    public static String timestampToString(Timestamp timestamp, SimpleDateFormat simpleDateFormat) {
        return simpleDateFormat.format(timestamp);
    }

    /**
     * Timestamp 转 String
     */
    public static String timestampToString(Timestamp timestamp, String simpleDateFormatStr) {
        return simpleDateFormat.get(simpleDateFormatStr).format(timestamp);
    }


    /**
     * String 转 LocalDateTime
     */
    public static LocalDateTime stringToLocalDateTime(String strDateTime) {
        return LocalDateTime.parse(strDateTime, DateTimeFormatter.ofPattern(getTimeFormat(strDateTime)));
    }

    /**
     * String 转 LocalDateTime
     */
    public static LocalDateTime stringToLocalDateTime(String strDateTime, String formatStr) {
        return LocalDateTime.parse(strDateTime, DateTimeFormatter.ofPattern(formatStr));
    }

    /**
     * String 转 LocalDate
     */
    public static LocalDate stringToLocalDate(String strDateTime) {
        return LocalDate.parse(strDateTime, localDateTimeFormat.get(yMd));
    }

    /**
     * String 转 Date
     */
    public static Date stringToDate(String strDateTime) {
        try {
            return simpleDateFormat.get(getTimeFormat(strDateTime)).parse(strDateTime);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * String 转 Timestamp
     */
    public static Timestamp stringToTimestamp(String strDateTime) {
        return Timestamp.valueOf(strDateTime);
    }

    /**
     * String 转 LocalTime
     */
    public static LocalTime stringToLocalTime(String strDateTime, String datetimeFormat) {
        return LocalTime.parse(strDateTime, DateTimeFormatter.ofPattern(datetimeFormat));
    }

    /**
     * String 转 LocalTime
     */
    public static LocalTime stringToLocalTime(String strDateTime) {
        return LocalTime.parse(strDateTime, DateTimeFormatter.ofPattern(HmsSSS));
    }

    /**
     * String 转 Time
     */
    public static Time stringToTime(String strDateTime) {
        return Time.valueOf(strDateTime);
    }

    /**
     * Long 转 Date
     */
    public static Date longToDate(Long time) {
        return new Date(time);
    }

    /**
     * Long 转 LocalDateTime
     */
    public static LocalDateTime longToLocalDateTime(Long time) {
        return LocalDateTime.ofInstant(Instant.ofEpochMilli(time), ZoneId.systemDefault());
    }

    /**
     * Long 转 LocalDate
     */
    public static LocalDate longToLocalDate(Long time) {
        return LocalDateTime.ofInstant(Instant.ofEpochMilli(time),ZoneId.systemDefault()).toLocalDate();
    }

    private static String getTimeFormat(String strDateTime) {
        if (null == strDateTime) {
            throw new RuntimeException("获取时间格式错误, time =" + strDateTime);
        }
        String data;
        data = strDateTime.trim();
        if ("".equals(data) || "null".equals(data)){
            throw new RuntimeException("获取时间格式错误, time =" + strDateTime);
        }
        String timeFormat = yMdHms;
        if (yPattern.matcher(data).matches()) {
            timeFormat = y;
        } else if (yMPattern.matcher(data).matches()) {
            timeFormat = yM;
        } else if (yMdPattern.matcher(data).matches()) {
            timeFormat = yMd;
        } else if (yMdHPattern.matcher(data).matches()) {
            timeFormat = yMdH;
        } else if (yMdHmPattern.matcher(data).matches()) {
            timeFormat = yMdHm;
        } else if (yMdHmsPattern.matcher(data).matches()) {
            timeFormat = yMdHms;
        } else if (yMdHmsSPattern.matcher(data).matches()) {
            timeFormat = yMdHmsS;
        } else if (yMdHmsSSSPattern.matcher(data).matches()) {
            timeFormat = yMdHmsSSS;
        }
        return timeFormat;
    }
}

测试

import org.junit.Assert;
import org.junit.Test;

import java.sql.Time;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;

import static com.simon.ocean.LocalDateTimeUtil.*;


/**
 * @author shizi
 * @since 2020/10/19 6:44 下午
 */
public class LocalDateTimeUtilTest {

    @Test
    public void localDateTimeToOtherTest() {
        LocalDateTime localDateTime = LocalDateTime.of(2020, 12, 20, 12, 12, 12, 123);

        Assert.assertEquals(Long.valueOf(1608437532000L), LocalDateTimeUtil.localDateTimeToLong(localDateTime));
        Assert.assertEquals("Sun Dec 20 12:12:12 CST 2020", LocalDateTimeUtil.localDateTimeToDate(localDateTime).toString());
        Assert.assertEquals("2020-12-20 12:12:12", LocalDateTimeUtil.localDateTimeToString(localDateTime));

        Assert.assertEquals("2020-12-20 12:12:12.000", LocalDateTimeUtil.localDateTimeToString(localDateTime, yMdHmsSSS));
        Assert.assertEquals("2020-12-20 12:12:12", LocalDateTimeUtil.localDateTimeToString(localDateTime, yMdHms));
        Assert.assertEquals("2020-12-20 12:12", LocalDateTimeUtil.localDateTimeToString(localDateTime, yMdHm));
        Assert.assertEquals("2020-12-20 12", LocalDateTimeUtil.localDateTimeToString(localDateTime, yMdH));
        Assert.assertEquals("2020-12-20", LocalDateTimeUtil.localDateTimeToString(localDateTime, yMd));
        Assert.assertEquals("2020-12", LocalDateTimeUtil.localDateTimeToString(localDateTime, yM));
        Assert.assertEquals("2020", LocalDateTimeUtil.localDateTimeToString(localDateTime, y));

        Assert.assertEquals("2020-12-20 12:12:12.000", LocalDateTimeUtil.localDateTimeToString(localDateTime, DateTimeFormatter.ofPattern(yMdHmsSSS)));
        Assert.assertEquals("2020-12-20 12:12:12", LocalDateTimeUtil.localDateTimeToString(localDateTime, DateTimeFormatter.ofPattern(yMdHms)));
        Assert.assertEquals("2020-12-20 12:12", LocalDateTimeUtil.localDateTimeToString(localDateTime, DateTimeFormatter.ofPattern(yMdHm)));
        Assert.assertEquals("2020-12-20 12", LocalDateTimeUtil.localDateTimeToString(localDateTime, DateTimeFormatter.ofPattern(yMdH)));
        Assert.assertEquals("2020-12-20", LocalDateTimeUtil.localDateTimeToString(localDateTime, DateTimeFormatter.ofPattern(yMd)));
        Assert.assertEquals("2020-12", LocalDateTimeUtil.localDateTimeToString(localDateTime, DateTimeFormatter.ofPattern(yM)));
        Assert.assertEquals("2020", LocalDateTimeUtil.localDateTimeToString(localDateTime, DateTimeFormatter.ofPattern(y)));
    }

    @Test
    public void localDateToOtherTest() {
        LocalDate localDate = LocalDate.of(2020, 12, 20);

        Date date = LocalDateTimeUtil.stringToDate("2020-12-20");
        Assert.assertEquals(date, LocalDateTimeUtil.localDateToDate(localDate));
        Assert.assertEquals(Long.valueOf(1608393600000L), LocalDateTimeUtil.localDateToLong(localDate));
        Assert.assertEquals("2020-12-20", LocalDateTimeUtil.localDateToString(localDate));

        LocalDateTime localDateTime = LocalDateTime.of(2020, 12, 20, 0, 0, 0);
        Assert.assertEquals(localDateTime, LocalDateTimeUtil.localDateToLocalDateTime(localDate));
    }

    @Test
    public void dateToOtherTest() {
        Date date = LocalDateTimeUtil.stringToDate("2020-12-20 12:23:20");

        LocalDate localDate = LocalDate.of(2020, 12, 20);
        Assert.assertEquals(localDate, LocalDateTimeUtil.dateToLocalDate(date));

        LocalDateTime localDateTime = LocalDateTime.of(2020, 12, 20, 12, 23, 20);
        Assert.assertEquals(localDateTime, LocalDateTimeUtil.dateToLocalDateTime(date));

        Assert.assertEquals("2020-12-20 12:23:20", LocalDateTimeUtil.dateToString(date));

        Assert.assertEquals("2020-12-20 12:23:20.000", LocalDateTimeUtil.dateToString(date, new SimpleDateFormat(yMdHmsSSS)));
        Assert.assertEquals("2020-12-20 12:23:20", LocalDateTimeUtil.dateToString(date, new SimpleDateFormat(yMdHms)));
        Assert.assertEquals("2020-12-20 12:23", LocalDateTimeUtil.dateToString(date, new SimpleDateFormat(yMdHm)));
        Assert.assertEquals("2020-12-20 12", LocalDateTimeUtil.dateToString(date, new SimpleDateFormat(yMdH)));
        Assert.assertEquals("2020-12-20", LocalDateTimeUtil.dateToString(date, new SimpleDateFormat(yMd)));
        Assert.assertEquals("2020-12", LocalDateTimeUtil.dateToString(date, new SimpleDateFormat(yM)));
        Assert.assertEquals("2020", LocalDateTimeUtil.dateToString(date, new SimpleDateFormat(y)));

        Assert.assertEquals("2020-12-20 12:23:20.000", LocalDateTimeUtil.dateToString(date, yMdHmsSSS));
        Assert.assertEquals("2020-12-20 12:23:20", LocalDateTimeUtil.dateToString(date, yMdHms));
        Assert.assertEquals("2020-12-20 12:23", LocalDateTimeUtil.dateToString(date, yMdHm));
        Assert.assertEquals("2020-12-20 12", LocalDateTimeUtil.dateToString(date, yMdH));
        Assert.assertEquals("2020-12-20", LocalDateTimeUtil.dateToString(date, yMd));
        Assert.assertEquals("2020-12", LocalDateTimeUtil.dateToString(date, yM));
        Assert.assertEquals("2020", LocalDateTimeUtil.dateToString(date, y));
    }

    @Test
    public void timestampToOtherTest() {
        Date date = LocalDateTimeUtil.stringToDate("2020-12-20 12:23:20.123");
        Timestamp timestamp = new Timestamp(date.getTime());

        LocalDate localDate = LocalDate.of(2020, 12, 20);
        Assert.assertEquals(localDate, LocalDateTimeUtil.timestampToLocalDate(timestamp));

        Timestamp timestamp1 = Timestamp.valueOf("2020-12-20 12:23:20.000000123");
        LocalDateTime localDateTime = LocalDateTime.of(2020, 12, 20, 12, 23, 20, 123);
        Assert.assertEquals(localDateTime, LocalDateTimeUtil.timestampToLocalDateTime(timestamp1));
        Assert.assertEquals(Long.valueOf(1608438200000L), LocalDateTimeUtil.timestampToLong(timestamp1));

        Assert.assertEquals("2020-12-20 12:23:20.000", LocalDateTimeUtil.timestampToString(timestamp1));

        Assert.assertEquals("2020-12-20 12:23:20.000", LocalDateTimeUtil.timestampToString(timestamp1, new SimpleDateFormat(yMdHmsSSS)));
        Assert.assertEquals("2020-12-20 12:23:20", LocalDateTimeUtil.timestampToString(timestamp1, new SimpleDateFormat(yMdHms)));
        Assert.assertEquals("2020-12-20 12:23", LocalDateTimeUtil.timestampToString(timestamp1, new SimpleDateFormat(yMdHm)));
        Assert.assertEquals("2020-12-20 12", LocalDateTimeUtil.timestampToString(timestamp1, new SimpleDateFormat(yMdH)));
        Assert.assertEquals("2020-12-20", LocalDateTimeUtil.timestampToString(timestamp1, new SimpleDateFormat(yMd)));
        Assert.assertEquals("2020-12", LocalDateTimeUtil.timestampToString(timestamp1, new SimpleDateFormat(yM)));
        Assert.assertEquals("2020", LocalDateTimeUtil.timestampToString(timestamp1, new SimpleDateFormat(y)));

        Assert.assertEquals("2020-12-20 12:23:20.000", LocalDateTimeUtil.timestampToString(timestamp1, yMdHmsSSS));
        Assert.assertEquals("2020-12-20 12:23:20", LocalDateTimeUtil.timestampToString(timestamp1, yMdHms));
        Assert.assertEquals("2020-12-20 12:23", LocalDateTimeUtil.timestampToString(timestamp1, yMdHm));
        Assert.assertEquals("2020-12-20 12", LocalDateTimeUtil.timestampToString(timestamp1, yMdH));
        Assert.assertEquals("2020-12-20", LocalDateTimeUtil.timestampToString(timestamp1, yMd));
        Assert.assertEquals("2020-12", LocalDateTimeUtil.timestampToString(timestamp1, yM));
        Assert.assertEquals("2020", LocalDateTimeUtil.timestampToString(timestamp1, y));
    }

    @Test
    public void stringToOtherTest() {
        String timeStr = "2020-12-20 12:23:20.123";

        LocalDateTimeUtil.stringToDate(timeStr);
        Date date = LocalDateTimeUtil.stringToDate("2020-12-20 12:23:20.123");
        Assert.assertEquals(date, LocalDateTimeUtil.stringToDate(timeStr));

        Time time = Time.valueOf("12:23:20");
        Assert.assertEquals(time, LocalDateTimeUtil.stringToTime("12:23:20"));

        LocalDate localDate = LocalDate.of(2020, 12, 20);
        Assert.assertEquals(localDate, LocalDateTimeUtil.stringToLocalDate("2020-12-20"));


        LocalDateTime localDateTime1 = LocalDateTime.of(2020, 10, 17, 11, 26, 33);
        Assert.assertEquals(localDateTime1, LocalDateTimeUtil.stringToLocalDateTime("2020-10-17 11:26:33"));

        LocalDateTime localDateTime2 = LocalDateTime.of(2020, 10, 17, 11, 26, 33, 0);
        Assert.assertEquals(localDateTime2, LocalDateTimeUtil.stringToLocalDateTime("2020-10-17 11:26:33.0"));


        LocalTime localTime1 = LocalTime.of(12, 23, 20, 123);
        Assert.assertEquals(localTime1, LocalDateTimeUtil.stringToLocalTime("12:23:20.000000123", "HH:mm:ss.SSSSSSSSS"));

        LocalTime localTime11 = LocalTime.of(12, 23, 20, 0);
        Assert.assertEquals(localTime11, LocalDateTimeUtil.stringToLocalTime("12:23:20.000", "HH:mm:ss.SSS"));

        LocalTime localTime2 = LocalTime.of(12, 23, 20);
        Assert.assertEquals(localTime2, LocalDateTimeUtil.stringToLocalTime("12:23:20", "HH:mm:ss"));

        LocalTime localTime3 = LocalTime.of(12, 23);
        Assert.assertEquals(localTime3, LocalDateTimeUtil.stringToLocalTime("12:23", "HH:mm"));

        Assert.assertEquals(localTime1, LocalDateTimeUtil.stringToLocalTime("12:23:20.000000123", HmsSSSMore));
        Assert.assertEquals(localTime11, LocalDateTimeUtil.stringToLocalTime("12:23:20.000", HmsSSS));
        Assert.assertEquals(localTime2, LocalDateTimeUtil.stringToLocalTime("12:23:20", Hms));
        Assert.assertEquals(localTime3, LocalDateTimeUtil.stringToLocalTime("12:23", Hm));

        Timestamp timestamp = Timestamp.valueOf("2020-12-20 12:23:20.000000123");
        Assert.assertEquals(timestamp, LocalDateTimeUtil.stringToTimestamp("2020-12-20 12:23:20.000000123"));
    }
}

更多工具详见这里
https://github.com/SimonAlong/Doramon

老柿子
关注
专栏目录
时间转换小工具
03-20
支持GPS时、UTC等时间系统的想换转换。
GNSS时间转换工具
03-31
GNSS时间转换，支持utc,儒略日，gps时相互转换（源于GPSTK）
长整型时间转换工具
01-02
长整型时间转换工具就是为了解决这类时间数据的处理问题而设计的。 首先，我们来理解什么是长整型时间。在计算机科学中，长整型通常用来表示大范围的整数，其位数比普通整型要多，因此能存储更大的数值。在处理时间...
日期时间转换工具.zip
06-11
日期时间转换工具是一种在计算机软件领域中常见的实用程序，它主要功能是帮助用户在不同的日期时间格式之间进行转换。在日常工作中，我们可能需要处理来自不同系统或国家的日期和时间数据，这些数据可能遵循各自的...
sntp测试及时间转换工具
12-20
sntp 客户端及服务端 时间转换 缺少环境
Java - DateUtil 日期时间转换工具类
最新发布
12-13
资源名称：DateUtil 日期时间转换工具类 内容概要：日期时间转换工具类，包括基本的Date类型，String类型，TimeStamp类型，LocalDateTime类型，LocalDate类型之间的互相转换，还提供了许多与时间获取，时间计算有关...
时间转换工具类
05-23
1、获取系统当前时间： 返回字符串格式 yyyy-MM-dd HH:mm:ss 、yyyyMMddHHmmss 返回短时间字符串格式yyyy-MM-dd 获取时间 小时:分;秒 HH:mm:ss 2、将长时间格式字符串转换为时间 yyyy-MM-dd HH:mm:ss 将长时间格式时间转换为字符串 yyyy-MM-dd HH:mm:ss 将短时间格式时间转换为字符串 yyyy-MM-dd 将短时间格式字符串转换为时间 yyyy-MM-dd 将短时间格式字符串转换为时间 yyyy-MM-dd HH:mm:ss 3、获取系统当前时间 4提取一个月中的最后一天 。。。。。。。。。。。。
时间转换软件
09-19
日期时间转换，主要是IC卡日期时间的计算，十六进制代码
UNIX时间戳转换工具
10-31
支持将Unix时间戳转换为UTC时间，也可以将UTC时间转换为Unix时间戳；现在网上也有在线转的页面，不想在线可以下载到本地使用
TimeTicks时间双向转换工具-下载
11-28
TimeTicks时间双向转换工具-下载，支持时间和ticks的双向转换。
秒转换日期时间工具
03-02
将1970年1月1日到目前的秒转换成日期时间
时间转换器
Dryad_的博客
10-20 657
时间转换器 这是我慕课平台上的一个作业 时间transform #include&lt;stdio.h&gt; void main() { int bjt,utc; int bjt_h,bjt_m,utc_h; printf(“请输入北京时间:”); scanf("%d",&amp;bjt); bjt_h=bjt/100; if(bjt_h&lt;=7){ utc_h=bjt_h+16; } el...
Java时间转换工具类
"该资源提供了一个Java实现的时间转换工具类，包括将长时间戳转换为标准日期格式（"yyyy-MM-dd HH:mm:ss"）和显示小时、分钟和秒的格式（"MM-dd HH:mm:ss"）。此外，代码还涉及到计算时间差的方法。" 在Java编程中...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值