java处理timestamp以及和date转换关系的总结

timestamp数据类型用法Java在Java编程语言中，timestamp是一种用于表示时间戳的数据类型。

时间戳是一个特定的日期和时间，通常以毫秒为单位表示自某个固定的参考时间点（通常是1970年1月1日午夜）以来的时间。

在本文中，我们将详细介绍Java中的timestamp数据类型的用法。

我们将讨论如何创建、操作和格式化时间戳，以及如何在不同的时间和日期库之间进行转换。

创建timestamp对象在Java中，我们可以使用java.sql.Timestamp类来表示时间戳。

要创建一个时间戳对象，我们可以使用以下方法之一：// 创建当前时间的时间戳Timestamp timestamp = new Timestamp(System.currentTimeMillis());// 创建指定日期和时间的时间戳Timestamp timestamp = Timestamp.valueOf("2022-01-01 12:00:00");第一个方法使用System.currentTimeMillis()获取当前时间的毫秒数，并将其传递给Timestamp构造函数来创建时间戳对象。

第二个方法使用Timestamp.valueOf()方法来将一个字符串表示的日期和时间转换为时间戳对象。

时间戳的操作一旦我们创建了一个时间戳对象，我们可以对其进行各种操作。

以下是一些常用的时间戳操作方法：•getTime()：返回时间戳的毫秒数表示。

•before(Timestamp ts)：检查一个时间戳是否在另一个时间戳之前。

•after(Timestamp ts)：检查一个时间戳是否在另一个时间戳之后。

•compareTo(Timestamp ts)：将两个时间戳进行比较，返回一个整数表示它们的相对顺序。

•setTime(long time)：设置时间戳的毫秒数表示。

以下是使用这些方法的示例：Timestamp timestamp1 = Timestamp.valueOf("2022-01-01 12:00:00");Timestamp timestamp2 = Timestamp.valueOf("2022-01-02 12:00:00");long time1 = timestamp1.getTime(); // 获取时间戳的毫秒数boolean isBefore = timestamp1.before(timestamp2); // 检查timestamp1是否在time stamp2之前boolean isAfter = timestamp1.after(timestamp2); // 检查timestamp1是否在timest amp2之后int compareResult = pareTo(timestamp2); // 比较timestamp1和time stamp2的相对顺序timestamp1.setTime(System.currentTimeMillis()); // 设置时间戳的毫秒数为当前时间格式化timestamp在Java中，我们可以使用java.text.SimpleDateFormat类来格式化时间戳为指定的日期和时间字符串。

Java⽇期时间以及⽇期相互转换Java⽇期时间，以及相互转化，供⼤家参考，具体内容如下package com.study.string;import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Calendar;import java.util.Date;import java.util.GregorianCalendar;public class DateBase {public static void main(String[] args) throws ParseException {/** 获得当前时间*/Date date1 = new Date();long long1 = date1.getTime();//date类型，转为 long类型System.out.println(date1);//Sat Aug 26 08:36:36 GMT+08:00 2017System.out.println(long1);//1503708031359Calendar cale1 = Calendar.getInstance();date1 = cale1.getTime();//calendar 类型转为 date类型long1 = date1.getTime();System.out.println(cale1);System.out.println(date1);//Sat Aug 26 08:36:36 GMT+08:00 2017System.out.println(long1);/**设置时间*/long1 += 24*60*60*1000;date1.setTime(long1);System.out.println(date1);//Sun Aug 27 08:43:26 GMT+08:00 2017/** 格式化时间⽇期,⽆参数的默认格式，有参数的⾃定义格式。

timestamp java转年月日格式
在Java中，可以使用Java 8引入的java.time包来轻松地将时间戳转换为年月日格式。

以下是一个示例：
在这个示例中，我们首先使用Instant.ofEpochMilli(timestamp)从时间戳创建一个Instant对象。

然后，我们使用instant.atZone(ZoneId.systemDefault())将Instant转换为ZonedDateTime，这允许我们指定时区。

我们默认使用系统时区。

然后，我们使用DateTimeFormatter.ofPattern("yyyy-MM-dd")创建一个DateTimeFormatter对象，用于定义日期时间的格式。

在这个例子中，我们使用了"yyyy-MM-dd"格式，这将日期格式化为"年-月-日"的形式。

最后，我们使用zonedDateTime.format(formatter)将ZonedDateTime对象格式化为字符串，并打印出来。

1。

Java8中LocalDateTime与时间戳timestamp的互相转换Java8 LocalDateTime与timestamp转换将timestamp转为LocalDateTimepublic LocalDateTime timestamToDatetime(long timestamp){Instant instant = Instant.ofEpochMilli(timestamp);return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());}将LocalDataTime转为timestamppublic long datatimeToTimestamp(LocalDateTime ldt){long timestamp = ldt.toInstant(ZoneOffset.of("+8")).toEpochMilli();return timestamp;}我在⽹上还找到了另⼀个将datetime转为时间戳的⽅法：ZoneId zone = ZoneId.systemDefault();long timestamp = ldt.atZone(zone).toInstant().toEpochMilli();Java8的时间转为时间戳的⼤概的思路就是LocalDateTime先转为Instant，设置时区，然后转timestamp。

附⼀个Java8中的LocalDateTime⼯具类⼯具类package mon.utils.date;import java.time.*;import java.time.format.DateTimeFormatter;import java.time.temporal.ChronoUnit;import java.time.temporal.TemporalUnit;import java.util.Date;/** @author kingboy* @Date 2017/7/22 下午2:12* @Description LocalDateTimeUtils is used to Java8中的时间类*/public class LocalDateTimeUtils {//获取当前时间的LocalDateTime对象//LocalDateTime.now();//根据年⽉⽇构建LocalDateTime//LocalDateTime.of();//⽐较⽇期先后//LocalDateTime.now().isBefore(),//LocalDateTime.now().isAfter(),//Date转换为LocalDateTimepublic static LocalDateTime convertDateToLDT(Date date) {return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());}//LocalDateTime转换为Datepublic static Date convertLDTToDate(LocalDateTime time) {return Date.from(time.atZone(ZoneId.systemDefault()).toInstant());}//获取指定⽇期的毫秒public static Long getMilliByTime(LocalDateTime time) {return time.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();}//获取指定⽇期的秒public static Long getSecondsByTime(LocalDateTime time) {return time.atZone(ZoneId.systemDefault()).toInstant().getEpochSecond();}//获取指定时间的指定格式public static String formatTime(LocalDateTime time,String pattern) {return time.format(DateTimeFormatter.ofPattern(pattern));}//获取当前时间的指定格式public static String formatNow(String pattern) {return formatTime(LocalDateTime.now(), pattern);}//⽇期加上⼀个数,根据field不同加不同值,field为ChronoUnit.*public static LocalDateTime plus(LocalDateTime time, long number, TemporalUnit field) {return time.plus(number, field);}//⽇期减去⼀个数,根据field不同减不同值,field参数为ChronoUnit.*public static LocalDateTime minu(LocalDateTime time, long number, TemporalUnit field){return time.minus(number,field);}/*** 获取两个⽇期的差 field参数为ChronoUnit.** @param startTime* @param endTime* @param field 单位(年⽉⽇时分秒)* @return*/public static long betweenTwoTime(LocalDateTime startTime, LocalDateTime endTime, ChronoUnit field) { Period period = Period.between(LocalDate.from(startTime), LocalDate.from(endTime));if (field == ChronoUnit.YEARS) return period.getYears();if (field == ChronoUnit.MONTHS) return period.getYears() * 12 + period.getMonths();return field.between(startTime, endTime);}//获取⼀天的开始时间，2017,7,22 00:00public static LocalDateTime getDayStart(LocalDateTime time) {return time.withHour(0).withMinute(0).withSecond(0).withNano(0);}//获取⼀天的结束时间，2017,7,22 23:59:59.999999999public static LocalDateTime getDayEnd(LocalDateTime time) {return time.withHour(23).withMinute(59).withSecond(59).withNano(999999999);}}测试类package mon.localdatetimeutils;import mon.utils.date.LocalDateTimeUtils;import org.junit.Test;import java.time.LocalDateTime;import java.time.temporal.ChronoUnit;import static mon.utils.date.LocalDateTimeUtils.getDayEnd;import static mon.utils.date.LocalDateTimeUtils.getDayStart;/*** @author kingboy* @Date 2017/7/22 下午7:16* @Description LocaDateTimeUtilsTest is used to 测试LocalDateTime⼯具*/public class LocaDateTimeUtilsTest {@Testpublic void format_test() {System.out.println(LocalDateTimeUtils.formatNow("yyyy年MM⽉dd⽇ HH:mm:ss"));}@Testpublic void betweenTwoTime_test() {LocalDateTime start = LocalDateTime.of(1993, 10, 13, 11, 11);LocalDateTime end = LocalDateTime.of(1994, 11, 13, 13, 13);System.out.println("年:" + LocalDateTimeUtils.betweenTwoTime(start, end, ChronoUnit.YEARS));System.out.println("⽉:" + LocalDateTimeUtils.betweenTwoTime(start, end, ChronoUnit.MONTHS));System.out.println("⽇:" + LocalDateTimeUtils.betweenTwoTime(start, end, ChronoUnit.DAYS));System.out.println("半⽇:" + LocalDateTimeUtils.betweenTwoTime(start, end, ChronoUnit.HALF_DAYS));System.out.println("⼩时:" + LocalDateTimeUtils.betweenTwoTime(start, end, ChronoUnit.HOURS));System.out.println("分钟:" + LocalDateTimeUtils.betweenTwoTime(start, end, ChronoUnit.MINUTES));System.out.println("秒:" + LocalDateTimeUtils.betweenTwoTime(start, end, ChronoUnit.SECONDS));System.out.println("毫秒:" + LocalDateTimeUtils.betweenTwoTime(start, end, LIS));//=============================================================================================/*年:1⽉:13⽇:396半⽇:792⼩时:9506分钟:570362秒:34221720毫秒:34221720000*/}@Testpublic void plus_test() {//增加⼆⼗分钟System.out.println(LocalDateTimeUtils.formatTime(LocalDateTimeUtils.plus(LocalDateTime.now(),20,ChronoUnit.MINUTES), "yyyy年MM⽉dd⽇ HH:mm"));//增加两年System.out.println(LocalDateTimeUtils.formatTime(LocalDateTimeUtils.plus(LocalDateTime.now(),2,ChronoUnit.YEARS), "yyyy年MM⽉dd⽇ HH:mm"));//=============================================================================================/*2017年07⽉22⽇ 22:532019年07⽉22⽇ 22:33*/}@Testpublic void dayStart_test() {System.out.println(getDayStart(LocalDateTime.now()));System.out.println(getDayEnd(LocalDateTime.now()));//=============================================================================================/*2017-07-22T00:002017-07-22T23:59:59.999999999*/}}总结到此这篇关于Java8中LocalDateTime与时间戳timestamp互相转换的⽂章就介绍到这了,更多相关Java8 LocalDateTime与timestamp转换内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。

java中timestamp 时间戳转换时间的方法（实用版4篇）目录（篇1）1.java中timestamp时间戳转换时间的方法2.时间戳的概念和作用3.java中常用的时间戳转换方法4.时间戳转换方法的优缺点5.总结正文（篇1）一、java中timestamp时间戳转换时间的方法在Java中，timestamp时间戳是一种常用的时间表示方式，可以记录时间的起始点。

时间戳通常用于记录事件发生的时间，例如日志记录、数据传输等。

在Java中，可以使用以下方法将timestamp转换为可读的时间格式：1.DateFormat类：DateFormat类可以将timestamp转换为可读的时间格式。

例如，可以使用以下代码将timestamp转换为Date对象：Date date = new Date(timestamp);2.Calendar类：Calendar类可以获取当前时间的各个部分，例如年、月、日、时、分、秒等。

可以使用以下代码将timestamp转换为Calendar 对象：Calendar calendar = Calendar.getInstance();calendar.setTimeInMillis(timestamp);3.SimpleDateFormat类：SimpleDateFormat类可以根据指定的格式将timestamp转换为可读的时间格式。

例如，可以使用以下代码将timestamp转换为String类型的时间格式：String time = new SimpleDateFormat("yyyy-MM-ddHH:mm:ss").format(new Date(timestamp));二、时间戳的概念和作用时间戳是指计算机系统自动生成的一个序列号，用于记录时间的起始点。

在计算机系统中，时间戳通常用于记录事件发生的时间，例如日志记录、数据传输等。

时间戳可以用于比较两个时间点之间的差异，例如计算两个事件之间的时间间隔。

java时间戳与⽇期相互转换⼯具详解本⽂为⼤家分享了java⽇期与时间戳相互转换⼤全，供⼤家参考，具体内容如下package com.crm.util;import java.math.BigDecimal;import java.text.DecimalFormat;import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Calendar;import java.util.Date;/*** @author DingJiaCheng* */public class DateFormatUtil {/*** 时间戳转⽇期* @param ms* @return*/public static Date transForDate(Integer ms){if(ms==null){ms=0;}long msl=(long)ms*1000;SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");Date temp=null;if(ms!=null){try {String str=sdf.format(msl);temp=sdf.parse(str);} catch (ParseException e) {e.printStackTrace();}}return temp;}/*** 获取晚上9点半的时间戳** @return*/public static int getTimes(int day, int hour, int minute) {Calendar cal = Calendar.getInstance();cal.add(Calendar.DATE, day);cal.set(Calendar.HOUR_OF_DAY, hour);cal.set(Calendar.SECOND, 0);cal.set(Calendar.MINUTE, minute);cal.set(LISECOND, 0);return (int) (cal.getTimeInMillis() / 1000);}/*** 获取当前时间往上的整点时间** @return*/public static int getIntegralTime() {Calendar cal = Calendar.getInstance();cal.add(Calendar.HOUR_OF_DAY, 1);cal.set(Calendar.SECOND, 0);cal.set(Calendar.MINUTE, 0);cal.set(LISECOND, 0);return (int) (cal.getTimeInMillis() / 1000);}public static int getIntegralTimeEnd() {Calendar cal = Calendar.getInstance();cal.set(Calendar.HOUR_OF_DAY, 24);cal.set(Calendar.SECOND, 0);cal.set(Calendar.MINUTE, 0);cal.set(LISECOND, 0);return (int) (cal.getTimeInMillis() / 1000);}/*** 时间戳转⽇期* @param ms* @return*/public static Date transForDate3(Integer ms){if(ms==null){ms=0;}long msl=(long)ms*1000;SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm");Date temp=null;if(ms!=null){try {String str=sdf.format(msl);temp=sdf.parse(str);} catch (ParseException e) {e.printStackTrace();}}return temp;}/*** 时间戳转⽇期* @param ms* @return*/public static Date transForDate(Long ms){if(ms==null){ms=(long)0;}long msl=(long)ms*1000;SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); Date temp=null;if(ms!=null){try {String str=sdf.format(msl);temp=sdf.parse(str);} catch (ParseException e) {e.printStackTrace();}}return temp;}public static String transForDate1(Integer ms){String str = "";if(ms!=null){long msl=(long)ms*1000;SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); if(ms!=null){try {str=sdf.format(msl);} catch (Exception e) {e.printStackTrace();}}}return str;}public static String transForDate2(Integer ms){String str = "";if(ms!=null){long msl=(long)ms*1000;SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");if(ms!=null){try {str=sdf.format(msl);} catch (Exception e) {e.printStackTrace();}}}return str;}public static String transForDate4(Integer ms){String str = "";if(ms!=null){long msl=(long)ms*1000;SimpleDateFormat sdf=new SimpleDateFormat("yyyy.MM.dd");if(ms!=null){try {str=sdf.format(msl);} catch (Exception e) {e.printStackTrace();}}}return str;}public static String transForDate5(Integer ms){String str = "";if(ms!=null){long msl=(long)ms*1000;SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");if(ms!=null){try {str=sdf.format(msl);} catch (Exception e) {e.printStackTrace();}}}return str;}public static String transForDateInChinese(Integer ms){String str = "";if(ms!=null){long msl=(long)ms*1000;SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM⽉dd⽇ HH:mm:ss"); if(ms!=null){try {str=sdf.format(msl);} catch (Exception e) {e.printStackTrace();}}}return str;}/*** ⽇期转时间戳* @param date* @return*/public static Integer transForMilliSecond(Date date){if(date==null) return null;return (int)(date.getTime()/1000);}/*** 获取当前时间戳* @return*/public static Integer currentTimeStamp(){return (int)(System.currentTimeMillis()/1000);/*** ⽇期字符串转时间戳* @param dateStr* @return*/public static Integer transForMilliSecond(String dateStr){Date date = DateFormatUtil.formatDate(dateStr);return date == null ? null : DateFormatUtil.transForMilliSecond(date);}/*** ⽇期字符串转时间戳* @param dateStr* @return*/public static Integer transForMilliSecond(String dateStr,String format){Date date = DateFormatUtil.formatDate(dateStr,format);return date == null ? null : DateFormatUtil.transForMilliSecond(date);}/*** ⽇期字符串转时间戳* @param dateStr* @param 格式如"yyyy-mm-dd"* @return*/public static Integer transForMilliSecondByTim(String dateStr,String tim){ SimpleDateFormat sdf=new SimpleDateFormat(tim);Date date =null;try {date = sdf.parse(dateStr);} catch (ParseException e) {e.printStackTrace();}return date == null ? null : DateFormatUtil.transForMilliSecond(date);}/*** 字符串转⽇期，格式为："yyyy-MM-dd HH:mm:ss"* @param dateStr* @return*/public static Date formatDate(String dateStr){SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); Date result=null;try {result = sdf.parse(dateStr);} catch (ParseException e) {e.printStackTrace();}return result;}/*** 字符串转⽇期，格式为："yyyy-MM-dd HH:mm:ss"* @param dateStr* @return*/public static Date formatDate(String dateStr,String format){SimpleDateFormat sdf=new SimpleDateFormat(format);Date result=null;try {result = sdf.parse(dateStr);} catch (ParseException e) {e.printStackTrace();}return result;}/*** ⽇期转字符串* @param date* @return*/public static String formatDate(Date date){SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); String result=null;result = sdf.format(date);return result;* ⽇期转字符串* @param date* @return*/public static String formatDate(Date date,String format){SimpleDateFormat sdf=new SimpleDateFormat(format);String result=null;result = sdf.format(date);return result;}/*** 时间戳格式化输出（httl模版⽤）** @param ms 时间戳* @param format 格式化* @return*/public static String transForDate(Integer ms, String format){ String str = "";if(ms!=null){long msl=(long)ms*1000;SimpleDateFormat sdf=new SimpleDateFormat(format); if(!ms.equals(0)){try {str=sdf.format(msl);} catch (Exception e) {e.printStackTrace();}}}return str;}/*** 取BigDecimal类型数的整数或⼩数部分（httl模版⽤）** @param b 值* @param mode 模式 0取整 1去⼩数部分* @return*/public static String splitBigDecimal(BigDecimal b, int mode) { DecimalFormat df = new DecimalFormat("0.00");String s = df.format(b);if(mode==0){return s.split("\\.")[0];}else {return "."+s.split("\\.")[1];}}/*** 计算两个⽇期之间差的天数（httl模版⽤）** @param ts1 时间戳1* @param ts2 时间戳2* @return*/public static int caculate2Days(Integer ts1, Integer ts2) {Date firstDate = DateFormatUtil.transForDate(ts1);Date secondDate = DateFormatUtil.transForDate(ts2);Calendar calendar = Calendar.getInstance();calendar.setTime(firstDate);int dayNum1 = calendar.get(Calendar.DAY_OF_YEAR);calendar.setTime(secondDate);int dayNum2 = calendar.get(Calendar.DAY_OF_YEAR);return Math.abs(dayNum1 - dayNum2);}/*** 给⼿机加密中间四位加星号** @param mobile* @return*/public String mobileSerect(String mobile){if(!StringUtils.isBlank(mobile)){int between = mobile.length()/2;mobile = mobile.substring(0, between-2)+"****"+mobile.substring(between+2, mobile.length()); }return mobile;}/*** 给邮箱加密加星号** @param email* @return*/public String emailSerect(String email) {if(!StringUtils.isBlank(email)){int length = stIndexOf("@");email = email.substring(0, 2)+"****"+email.substring(length-2, email.length());}return email;}/*** BigDecimal类型数据相加** @param BigDecimal source* @param BigDecimal target* @return*/public BigDecimal sumBigDicimal(BigDecimal source, BigDecimal target) {source = source.add(target);return source;}/*** BigDecimal类型数据相加** @param BigDecimal source* @param BigDecimal target* @return*/public BigDecimal sumBigDicimalAndDouble(BigDecimal source, Double target) {BigDecimal new_target = new BigDecimal(target);source = source.add(new_target);return source;}/*** BigDecimal类型数据相减** @param BigDecimal source* @param BigDecimal target* @return*/public BigDecimal subBigDicimal(BigDecimal source, BigDecimal target) {source = source.subtract(target);return source;}/*** 获取传⼊时间和当前时间的时间差* @return*/public static Long getTimediff(int timeStamp){Date d1 = DateFormatUtil.transForDate(timeStamp);Date today = new Date();if(d1.getTime()<today.getTime()){return null;}return (d1.getTime()-today.getTime())/1000;}/*** 获取某周的第⼀天⽇期* @param week 0 当周 1 上⼀周 -1 下⼀周* @return*/public static String weekFirstDay(int week){Calendar c1 = Calendar.getInstance();int dow = c1.get(Calendar.DAY_OF_WEEK);c1.add(Calendar.DATE, -dow-7*(week-1)-5 );String d1 = new SimpleDateFormat("yyyy-MM-dd").format(c1.getTime());return d1+" 00:00:00";}/*** 当前时间加⼀年*/public static String addYear(int startTime){Date firstDate = DateFormatUtil.transForDate(startTime);Calendar calendar = Calendar.getInstance();calendar.setTime(firstDate);calendar.add(Calendar.YEAR,1);String d1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(calendar.getTime());return d1;}/*** 获取某周的最后⼀天⽇期* @param week* @return*/public static String weekLastDay(int week){Calendar c1 = Calendar.getInstance();int dow = c1.get(Calendar.DAY_OF_WEEK);c1.add(Calendar.DATE, -dow-7*(week-1)+1);String d1 = new SimpleDateFormat("yyyy-MM-dd").format(c1.getTime());return d1+" 23:59:59";}/*** 和当前时间⽐对* @return*/public static boolean greaterThanNow(int timeStamp){Date d1 = DateFormatUtil.transForDate(timeStamp);Date today = new Date();if(d1.getTime()>=today.getTime()){return true;}return false;}/*** HH:mm:ss格式时间转换为1970-01-01⽇的时间戳（也就是只有时间没有⽇期的情况要求使⽤时间戳表⽰时间） * @author DingJiaCheng* */public static int transFromTime(String time){return transForMilliSecond("1970-01-01 "+time,"yyyy-mm-dd HH:mm:ss");}/*** 时间戳转换为HH：mm：ss格式时间(⽇期去除)* @author DingJiaCheng* */public static String transToTime(int time){String s = new String(transForDate1(time));String ss[] = s.split(" ");return ss[1];}public static int transToChuo(String dateString){SimpleDateFormat simpleDateFormat =new SimpleDateFormat("yyyy-MM-dd");int res = 0;try {Date date=simpleDateFormat .parse(dateString);res = (int) date.getTime();} catch (ParseException e) {e.printStackTrace();}return res;}public static void main(String[] args) {//System.out.println(getIntegralTimeEnd());System.out.println(transForDate2(transForMilliSecond("2015-02-25 00:00:00")));//System.out.println(transForMilliSecond("2016-01-25","yyyy-mm-dd"));//System.out.println(transForDate1(transForMilliSecond("1970-01-01 00:00:00","yyyy-mm-dd HH:mm:ss"))); //System.out.println(currentTimeStamp());//System.out.println(transForDate(currentTimeStamp()));//System.out.println(new Date());//System.out.println(DateUtils.getDate());System.out.println(transFromTime("00:00:01"));System.out.println(transToTime(transFromTime("15:01:13")));}}以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

java⽇期互转：LocalDateTime、String、TimeStamp、Long、。

由于java版本的迭代，⼀个使⽤java开发的项⽬中可能出现多种⽇期对象，例如LocalDateTime、LocalDate、Date，不像C#只有⼀个DateTime，因此在各种⽇期格式或者对象之间的转换显得有点复杂，总是记不住，在需要⽤到时总是需要依靠搜索引擎，有点浪费时间，所以特意把常⽤的转换场景总结如下：1、 LocalDateTime转为String、TimeStamp、Long、Instant、 DateSystem.out.println("----------------LocalDateTime----------------");//LocalDateTime -> StringString localDateTimeToString = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));System.out.println("LocalDateTime -> String: " + localDateTimeToString);//LocalDateTime -> TimeStampTimestamp localDateTimeToTimeStamp = Timestamp.valueOf(LocalDateTime.now());System.out.println("LocalDateTime -> TimeStamp: " + localDateTimeToTimeStamp);//LocalDateTime -> LongLong localDateTimeToLong = Timestamp.valueOf(LocalDateTime.now()).getTime();System.out.println("LocalDateTime -> Long: " + localDateTimeToLong);//LocalDateTime -> InstantInstant localDateTimeToInstant = LocalDateTime.now().atZone(ZoneId.systemDefault()).toInstant();System.out.println("LocalDateTime -> Instant: " + localDateTimeToInstant);//LocalDateTime -> DateDate LocalDateTimeToDate = Date.from(LocalDateTime.now().atZone(ZoneId.systemDefault()).toInstant());System.out.println("LocalDateTime -> Date: " + LocalDateTimeToDate);2、String转为LocalDateTime、 DateSystem.out.println("----------------String----------------");//String -> LocalDateTimeLocalDateTime stringToLocalDateTime =LocalDateTime.parse("2018-03-11 15:30:11", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));System.out.println("String -> LocalDateTime: " + stringToLocalDateTime);//String -> Datetry {Date stringToDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2018-03-11 15:30:11");System.out.println("String -> Date: " + stringToDate);} catch (ParseException ex) {}3、Timestamp转为LocalDateTime、 DateSystem.out.println("---------------Timestamp-----------------");//Timestamp -> LocalDateTimeLocalDateTime timeStampToLocalDateTime =LocalDateTime.ofInstant(new Timestamp(1520754566856L).toInstant(), ZoneId.systemDefault());System.out.println("Timestamp -> LocalDateTime: " + timeStampToLocalDateTime);//Timestamp -> DateDate timestampToDate = Date.from(new Timestamp(1520754566856L).toInstant());System.out.println("Timestamp -> Date: " + timestampToDate);4、Long转为LocalDateTime、 DateSystem.out.println("---------------Long-----------------");//Long -> LocalDateTimeLocalDateTime longToLocalDateTime =LocalDateTime.ofInstant(Instant.ofEpochMilli(1520754566856L), ZoneId.systemDefault());System.out.println("Long -> LocalDateTime: " + longToLocalDateTime);//Long -> DateDate longToDate = new Date(1520754566856L);System.out.println("Long -> Date: " + longToDate);5、Instant转为LocalDateTime、 DateSystem.out.println("----------------Instant----------------");//Instant -> LocalDateTimeLocalDateTime instantToLocalDateTime = LocalDateTime.ofInstant(Instant.now(), ZoneId.systemDefault());System.out.println("Instant -> LocalDateTime: " + instantToLocalDateTime);//Instant -> DateDate instantToDate = Date.from(Instant.now());System.out.println("Instant -> Date: " + instantToDate);6、Date转为LocalDateTime、String、TimeStamp、Long、InstantSystem.out.println("----------------Date----------------");//Date -> StringString dateToString = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());System.out.println("Date -> String: " + dateToString);//Date -> LocalDateTimeLocalDateTime dateToLocalDateTime = LocalDateTime.ofInstant(new Date().toInstant(), ZoneId.systemDefault()); System.out.println("Date -> LocalDateTime: " + dateToLocalDateTime);//Date -> TimestampTimestamp dateToTimestamp = new Timestamp(new Date().getTime());System.out.println("Date -> Timestamp: " + dateToTimestamp);//Date -> LongLong dateToLong = new Date().getTime();System.out.println("Date -> Long: " + dateToLong);//Date -> InstantInstant dateToInstant = new Date().toInstant();System.out.println("Date -> Instant: " + dateToInstant);。

【Java】时间戳与Date相互转换时间戳转Datepublic static void main(String[] args) {// 10位的秒级别的时间戳long time1 = 1527767665;String result1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(time1 * 1000));System.out.println("10位数的时间戳（秒）--->Date:" + result1);Date date1 = new Date(time1*1000); //对应的就是时间戳对应的Date// 13位的秒级别的时间戳double time2 = 1515730332000d;String result2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(time2);System.out.println("13位数的时间戳（毫秒）--->Date:" + result2);}10位数的时间戳（秒）--->Date:2018-05-31 19:54:2513位数的时间戳（毫秒）--->Date:2018-01-12 12:12:12尤其要注意上⾯10位的秒级别的时间戳时，不能⽤int来定义time1变量，否则会得到错误的结果：public static void main(String[] args) {// 10位的秒级别的时间戳int time1 = 1527767665; //错误做法String result1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(time1 * 1000));System.out.println("10位数的时间戳（秒）--->Date:" + result1);}10位数的时间戳（秒）--->Date:1969-12-17 23:21:47Date转时间戳public static void main(String[] args) {//获取指定时间的时间戳，除以1000说明得到的是秒级别的时间戳（10位）long time = (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")).parse("2018-06-30 20:00:00", new ParsePosition(0)).getTime() / 1000;//获取时间戳long now1 = System.currentTimeMillis();long now2 = new Date().getTime();System.out.println("获取指定时间的时间戳:" + time);System.out.println("当前时间戳:" +now1);System.out.println("当前时间戳:" +now2);}获取指定时间的时间戳:1530360000当前时间戳:1527769494340当前时间戳:1527769494340格式化Datepublic static void main(String[] args) {//使⽤common-lang包下⾯的DateFormatUtils类String format1 = DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss");//使⽤最原始的SimpleDateFormat类String format2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());System.out.println("格式化时间1:" + format1);System.out.println("格式化时间2:" + format2);}格式化时间1:2018-05-31 20:26:49格式化时间2:2018-05-31 20:26:49DateFormatUtils是ng3.time.DateFormatUtils下的，如果你的项⽬中没有，maven中引⼊下：<dependency><groupId>mons</groupId><artifactId>commons-lang3</artifactId><version>3.6</version></dependency>给⽇期加上指定时长⽐如，给现在的时间加上12个⼩时，这个需求也很常见，例如我做过的某个秒杀接⼝要返回剩余秒杀时间给前端，那么我就直接计算（⽐如秒杀持续时间为12⼩时）：秒杀(倒计时)截⽌时间=（当前时间+12H）即可。

Java时区转换及Date类实现原理解析这篇⽂章主要介绍了Java时区转换及Date类实现原理解析,⽂中通过⽰例代码介绍的⾮常详细，对⼤家的学习或者⼯作具有⼀定的参考学习价值,需要的朋友可以参考下⼀、时区的说明地球表⾯按经线从东到西，被划成⼀个个区域，规定相邻区域的时间相差1⼩时。

在同⼀区域内的东端和西端的⼈看到太阳升起的时间最多相差不过1⼩时。

当⼈们跨过⼀个区域，就将⾃⼰的时钟校正1⼩时（向西减1⼩时，向东加1⼩时），跨过⼏个区域就加或减⼏⼩时 ,所以同⼀时刻在不同时区表⽰的时间是不⼀样的。

⼆、时间的表⽰我们平时表⽰时间时通常是以⼀个格式化的字符串来表⽰⼀个时间，例如"2019-11-5 20:05"这个字符串表⽰的是2019年11⽉5⽇20点05分。

但这⾥有⼀个隐含的前提，时区是⾃⼰当前所在的时区，即东⼋区的⼈看到这个时间认为是东⼋区的20:05,⽽东九区的⼈会认为是东九区的20:05,实际上这两个时间相差了⼀个⼩时。

所以要正确的表⽰⼀个特定时刻，还要再加上时区信息，例如"2019-11-5 20:05 +8:00"这个字符串不管哪个时区的⼈看到都知道表⽰的是东⼋区的时间。

三、时间戳时间戳表⽰的是⼀个时间间隔，从0时区来看，表⽰从"1970-1-1 00:00 +0:00"到现在(2019-11-5 12:05 +0:00)时刻的时间间隔，⽽从东⼋区来看表⽰从"1970-1-1 08:00 +8:00"到现在(2019-11-5 20:05 +8:00)的时间间隔。

间隔=现在-起点，因为现在和起点都相差了8⼩时，所以时间间隔是⼀样的，同样的道理，在任意时区中现在这⼀个时刻的时间戳都是⼀样的。

四、Date类和时间戳java的Date类中实际保存的是某⼀个时刻的时间戳，所以同⼀时刻在任意时区获取到的Date对象都是⼀样的。

java中timestamp 时间戳转换时间的方法（实用版4篇）目录（篇1）1.Java 中 Timestamp 的定义与作用2.Timestamp 时间戳转换时间的方法3.Timestamp 与数据库连接时的日期处理4.示例代码及应用场景正文（篇1）在 Java 编程语言中，Timestamp 类表示一个时间戳，它可以用于表示具体的时间点，如年、月、日、时、分、秒等。

Timestamp 类提供了一种将时间戳转换为具体的时间表示方法，使得开发人员可以更加方便地处理和操作时间数据。

一、Java 中 Timestamp 的定义与作用Timestamp 类是 java.sql 包中的一个类，它继承自java.util.Date 类，并提供了一些额外的方法用于处理时间戳。

Timestamp 类的主要作用是用于数据库操作，特别是与 Oracle 数据库的交互。

在 Oracle 数据库中，时间戳被表示为 SQL Timestamp 类型，它可以精确到纳秒级别。

二、Timestamp 时间戳转换时间的方法Timestamp 类提供了多种方法来将时间戳转换为具体的时间表示。

以下是一些常用的方法：1.toLocalTime() 方法：将时间戳转换为当地的时间表示，返回一个java.time.LocalTime 对象。

2.toLocalDate() 方法：将时间戳转换为当地的日期表示，返回一个java.time.LocalDate 对象。

3.toInstant() 方法：将时间戳转换为瞬间（即时间点），返回一个java.time.Instant 对象。

4.toEpochMilli() 方法：将时间戳转换为从 1970-01-01T00:00:00Z 开始的毫秒数，返回一个 long 值。

5.toTime() 方法：将时间戳转换为时间（时：分:秒），返回一个java.time.LocalTime 对象。

6.toDate() 方法：将时间戳转换为日期（年 - 月-日），返回一个java.time.LocalDate 对象。

一、时间戳的定义及作用时间戳（timestamp）通常指的是某个特定时间点的标记，它可以被转换成日期和时间。

在计算机科学领域中，时间戳通常用来记录事件发生的时间，比如文件的创建时间、修改时间等。

在编程语言中，时间戳的类型可以根据不同的需求来选择，而在Java中，时间戳的类型主要有三种，分别是java.util.Date、java.sql.Timestamp和java.time.Instant。

二、java.util.Datejava.util.Date是Java中最早用于表示时间戳的类型之一。

它表示一个特定的时间点，精确到毫秒。

在java.util包中，Date类提供了一系列方法来操作时间戳，比如获取年、月、日、时、分、秒等信息。

不过，java.util.Date存在着一些问题，比如它内部使用的是长整型数值表示时间戳，这使得它无法准确地表示1970年1月1日之前的时间，因此在Java 8之后，新的时间处理类被引入，逐渐取代了java.util.Date的使用。

三、java.sql.Timestampjava.sql.Timestamp是java.util.Date的子类，它继承了Date类的所有特性，并且针对数据库中的时间类型进行了优化。

在Java中，java.sql.Timestamp主要用于和数据库进行时间戳的交互。

相比于java.util.Date，java.sql.Timestamp提供了更多的精确度，因此它更适合用于处理数据库中的时间戳数据。

另外，在某些情况下，java.sql.Timestamp也可以代替java.util.Date来使用，比如在需要进行数据库操作时、需要更高精确度的时间戳时等。

四、java.time.InstantJava 8引入了全新的日期时间API，其中最重要的一部分就是java.time包。

在java.time包中，Instant类被设计用来表示时间戳，它和java.util.Date有着类似的功能，但提供了更加丰富的功能和更高的精确度。

javaDate和数据库中各种时间的处理在开发web程序的时候，数据库的设计避免不了要设置有关于时间存储的字段。

这时候需要通过java的API进⾏时间字段的存⼊。

⼀、mysql数据库为例⼦ 如mysql数据库中的Date、DateTime、TimeStamp、Time类型 1、Date：没有时间部分。

以YYYY-MM-DD格式显⽰。

⽀持的范围是'1000-01-01'到'9999-12-31'。

需要3字节。

2、DateTime：有⽇期和时间部分。

以YYYY-MM-DD HH:MM:SS格式显⽰。

⽀持的范围是'1000-01-0100:00:00'到'9999-12-31 23:59:59'。

需要8字节。

3、Time：表⽰⼀天中的时间。

以HH:MM:SS格式显⽰。

⽀持的范围是'00:00:00'到'23:59:59'。

4、TimeStamp：默认情况下是使⽤当前的时间。

以YYYY-MM-DD HH:MM:SS格式显⽰。

需要4字节。

注意： (1) 在书写sql语句的时候，注意写⼊⽇期字段的时候⽤ ' ' 进⾏引⼊。

如：values( ' timeOne ' ) (2) 在⽇期的输⼊格式有很多种。

如常⽤的"yyyy年MM⽉dd⽇ HH时mm分ss秒"、"yyyy-MM-dd HH:mm:ss"、"yyyy/MM/dd HH:mm:ss"⼆、各种Date之间的转换 1、获取当前系统时间和设置输出格式Date date = new Date();// 设置⽇期格式SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");String format = simpleDateFormat.format(date);System.out.println(format);//输出格式：2020-02-13 10:30:44 2、String转为DateString time = "2020-02-13 10:30:44";SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");Date date = null;try {date = simpleDateFormat.parse(time);// 转为Date} catch (ParseException e) {e.printStackTrace();}System.out.println(date); // Thu Feb 13 10:30:44 CST 2020 3、String转为sql包中的DateString str = "2020-02-13";SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");java.sql.Date sqlDate = null;// sql包中的Datetry {java.util.Date utildate = simpleDateFormat.parse(str);sqlDate = new java.sql.Date(utildate.getTime());} catch (ParseException e) {e.printStackTrace();}System.out.println(sqlDate); //转换为 sql包中的Date 2020-02-13 4、Date转为StringDate date = new Date();SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); String str = simpleDateFormat.format(date);System.out.println(str); //输出格式 2020-02-13 10:38:10 5、Date转为Datetime/TimestampDate date = new Date();long time = date.getTime();Timestamp timestamp = new Timestamp(time);System.out.println(timestamp); // 2020-02-13 10:47:40.349 6、util.Date转换为sql.Date//util.DateDate date = new Date();long longTime = date.getTime(); // 1581562292229//sql.Datejava.sql.Date sDate = new java.sql.Date(longTime);System.out.println(sDate); // 2020-02-13System.out.println(longTime);。

java⽇期和timestamp互相转换背景：在项⽬测试过程中，需要⽤到long型的时间戳做测试。

因此需要将⽇期转换为long 型数据（顺带把long 型数据转换为⽇期的功能⼀并研究了⼀下）。

代码如下：1. 功能代码：1package com.wen.util.date;23import java.text.ParseException;4import java.text.SimpleDateFormat;5import java.util.Date;67public class Long_timer {89// Get the long value of the current date10public long get_long_time()11 {12 Date mydate=new Date();13return mydate.getTime();14 }1516public long date2long(String year,String month,String day,String hour,String minutes,String sec,String sss)17 {18 StringBuilder sb=new StringBuilder();19 sb.append(month);20 sb.append("/");21 sb.append(day);22 sb.append("/");23 sb.append(year);24 sb.append(" ");25 sb.append(hour);26 sb.append(":");27 sb.append(minutes);28 sb.append(":");29 sb.append(sec);30 sb.append(".");31 sb.append(sss);3233 String sDt = sb.toString();3435 SimpleDateFormat sdf=new SimpleDateFormat("MM/dd/yyyy HH:mm:ss.SSS");36 Date dt = null;37try {38 dt = sdf.parse(sDt);3940 } catch (ParseException e) {41// TODO Auto-generated catch block42 e.printStackTrace();43 }4445return dt.getTime();46 }4748public Date long2date(long timestamp)49 {50 Date mydate=new Date();51 mydate.setTime(timestamp);52return mydate;53 }54 }2. 测试代码：package com.wen.util.date;public class TestClient {public static void main(String[] args) {// TODO Auto-generated method stublong t=System.currentTimeMillis();Long_timer test= new Long_timer();System.out.println("current time is: "+t);System.out.println("the long time of now: "+test.get_long_time());System.out.println("the long time for specified date:"+test.date2long("2017","04","10","17","41","53","819"));} }。

Java中Date及Timestamp时间相关内容（基本上看这一份就可以了）java.util.date java.sql.date java.sql.timestamp整理一：这里的一片文章，我个人认为讲解的很详细，有对 java.sql.Date的使用还有困惑的请看。

java.sql.Date 只存储日期数据不存储时间数据// 会丢失时间数据preparedStatement.setDate(1, new java.sql.Date(date.getTime()));//可以这样来处理preparedStatement.setTimestamp(1, new java.sql.Timestamp(newjava.util.Date().getTime()));//想要得到完整的数据，包括日期和时间，可以这样java.util.Date d = resultSet.getTimestamp(1);//这样处理更合适一些，可以避免一些潜在Timestamp 问题java.util.Date d = newjava.util.Date(resultSet.getTimestamp(1).getTime());自己补的话这样的话：往数据库存储的时候可以接收 java.util.Date类型再用getTime()方法得到代表那个Date对象的long值，再以这个long值构造一个Timestamp 对象存进数据库中。

从存数据库里取的时候，可以先得到Timestamp用他的getTime()方法得到long值，再以这个long值构造一个 java.util.Date对象，这样就可以对这个Date对象操作了。

不如说 new SimpleTimeFormat("yyyyy-MM-ddHH:mm:ss").format()等等整理二：用Timestamp来记录日期时间还是很方便的，但有时候显示的时候是不需要小数位后面的毫秒的，这样就需要在转换为String时重新定义格式。

java.sql.Date和java.sql.Timestamp转换在开发web应⽤中，针对不同的数据库⽇期类型，我们需要在我们的程序中对⽇期类型做各种不同的转换。

若对应数据库数据是oracle的Date类型，即只需要年⽉⽇的，可以选择使⽤java.sql.Date类型，若对应的是MSsqlserver数据库的DateTime类型。

既需要年⽉⽇时分秒的，选择java.sql.Timestamp类型。

你可以使⽤dateFormat定义时间⽇期的格式，转⼀个字符串即可。

package personal.jessica;import java.util.Date;import java.util.Calendar;import java.sql.Timestamp;import java.text.DateFormat;import java.text.SimpleDateFormat;import java.util.Locale;class Datetest{/***method 将字符串类型的⽇期转换为⼀个timestamp（时间戳记java.sql.Timestamp）dateString 需要转换为timestamp的字符串dataTime timestamp*/public final static java.sql.Timestamp string2Time(String dateString)throws java.text.ParseException {DateFormat dateFormat;dateFormat = new SimpleDateFormat("yyyy-MM-dd kk:mm:ss.SSS", Locale.ENGLISH);//设定格式//dateFormat = new SimpleDateFormat("yyyy-MM-dd kk:mm:ss", Locale.ENGLISH);dateFormat.setLenient(false);java.util.Date timeDate = dateFormat.parse(dateString);//util类型//Timestamp类型,timeDate.getTime()返回⼀个long型java.sql.Timestamp dateTime = new java.sql.Timestamp(timeDate.getTime());return dateTime;}/***method 将字符串类型的⽇期转换为⼀个Date（java.sql.Date）dateString 需要转换为Date的字符串dataTime Date*/public final static java.sql.Date string2Date(String dateString)throws ng.Exception {DateFormat dateFormat;dateFormat = new SimpleDateFormat("yyyy-MM-dd", Locale.ENGLISH);dateFormat.setLenient(false);java.util.Date timeDate = dateFormat.parse(dateString);//util类型java.sql.Date dateTime = new java.sql.Date(timeDate.getTime());//sql类型return dateTime;}public static void main(String[] args){Date da = new Date();//注意：这个地⽅da.getTime()得到的是⼀个long型的值System.out.println(da.getTime());//由⽇期date转换为timestamp//第⼀种⽅法：使⽤new Timestamp(long)Timestamp t = new Timestamp(new Date().getTime());System.out.println(t);//第⼆种⽅法：使⽤Timestamp(int year,int month,int date,int hour,int minute,int second,int nano)Timestamp tt = new Timestamp(Calendar.getInstance().get(Calendar.YEAR) - 1900, Calendar.getInstance().get(Calendar.MONTH), Calendar.getInstance().get(Calendar.DATE), Calendar.getInstance().get(Calendar.HOUR), Calendar.getInstance().get(Calendar.MINUTE), Calendar.getInstance().get(Calendar.SECOND), 0);System.out.println(tt);try {String sToDate = "2005-8-18";//⽤于转换成java.sql.Date的字符串String sToTimestamp = "2005-8-18 14:21:12.123";//⽤于转换成java.sql.Timestamp的字符串Date date1 = string2Date(sToDate);Timestamp date2 = string2Time(sToTimestamp);System.out.println("Date:"+date1.toString());//结果显⽰System.out.println("Timestamp:"+date2.toString());//结果显⽰}catch(Exception e) {e.printStackTrace();}}}///:~怎样处理⼀个时间段，⽐如某⼈登陆了xx天xx⼩时xx分xx秒。

⽤Java操作数据库Datetime数据Date、Calendar、Timestamp的区别、相互转换与使⽤1 Java.util.Date包含年、⽉、⽇、时、分、秒信息。

1// String转换为Date2 String dateStr="2013-8-13 23:23:23";3 String pattern="yyyy-MM-dd HH:mm:ss";4 DateFormate dateFormat=new SimpleDateFormat(pattern);5 Date date=dateFormat.parse(dateStr);6 date=dateFormat.format(date);2 Java.sql.Date包含年、⽉、⽇信息，注意不包含时、分、秒信息。

继承⾃java.util.Date。

⽤来读写数据库中的时间类型的字段，⽽⽆法使⽤Java.util.Date类型来操作数据库中的时间类型字段。

1// java.util.Date转换为java.sql.Date2new java.sql.Date(utilDate.getTime());// 其中utilDate为java.util.Date类型的对象3 Java.util.Calendar包含年、⽉、⽇、时、分、秒、毫秒信息。

JDK1.1引⼊，⽤以代替java.util.Date。

1// Date转为Calendar2 Date date=new Date();3 Calendar calendar=Calendar.getInstance();4 calendar.setTime(date);56// Calendar转为Date7 Calendar ca=Calendar.getInstance();8 Date d =(Date) ca.getTime();4 Java.sql.Timestamp包含年、⽉、⽇、时、分、秒、纳秒（nano）信息。

JAVA中⽇期转换和⽇期计算的⽅法 ⽇期的格式有很多形式，在使⽤过程中经常需要转换，下⾯是各种类型转换的使⽤例⼦以及⽇期计算⽅法的例⼦。

⼀、不同格式⽇期相互转换⽅法1public class TestDateConvertUtil {23public static void main(String[] args) throws ParseException {4// 获取当前时间5 Date date = new Date(); // 获取当前时间6long timestamp = System.currentTimeMillis(); // 获取当前时间戳78// ⽇期格式转换9 date2String(); // ⽇期转字符串10 string2Date(); // 字符串转⽇期11 date2Timestamp(); // ⽇期转时间戳12 timestamp2Date(); // 时间戳转⽇期13 cst2Date(); // CST格式转⽇期14 nonstandard2Date(); // ⾮标准格式转⽇期15 convertDateStr(); // ⽇期字符串格式转换16 date2Calendar(); // ⽇期转⽇历17 calendar2Date(); // ⽇历转⽇期18 }1920public static void date2String() {21 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");22 Date date = new Date();23 String dateStr = sdf.format(date);24 System.out.println(dateStr);25 }2627public static void string2Date() throws ParseException {28 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");29 String dateStr = "2018-05-16 19:30:20";30 Date date = sdf.parse(dateStr);31 System.out.println(date);32 }3334public static void date2Timestamp() {35 Date date = new Date();36 String timestamp = String.valueOf(date.getTime());37 System.out.println(timestamp);38 }3940public static void timestamp2Date() {41 String timestamp = "1526470220000";42 Date date = new Date(new Long(timestamp));43 System.out.println(date);44 }4546public static void cst2Date() throws ParseException {47 SimpleDateFormat sdf = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy", ); // 注意使⽤参数48 String cst = "Tue May 16 19:30:20 CST 2018";49 Date date = sdf.parse(cst);50 System.out.println(date);51 }5253public static void nonstandard2Date() throws ParseException {54 SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");55 sdf.setLenient(false); // 设置严格验证⽇期56 String dateStr = "20180516";57 Date date = sdf.parse(dateStr);58 System.out.println(date);59 }6061public static void convertDateStr() throws ParseException {62 SimpleDateFormat sdfSource = new SimpleDateFormat("yyyyMMdd");63 SimpleDateFormat sdfTarget = new SimpleDateFormat("yyyy-MM-dd");64 String dateSource = "20180516";65 String dateTarget = sdfTarget.format(sdfSource.parse(dateSource));66 System.out.println(dateTarget);67 }6869public static void date2Calendar() {70 Date date = new Date();71 Calendar c = Calendar.getInstance();72 c.setTime(date);73 System.out.println(c);74 }7576public static void calendar2Date() {77 Calendar c = Calendar.getInstance();78 Date date = c.getTime();79 System.out.println(date);80 }81 } 例⼦中，setLenient⽅法默认值为true，意思为宽泛的⽇期格式校验，⽐如20180532这样的值转date类型，会⾃动变成20180601。

Java获取当前时间及String、datetime、date相互转化⼀、获取当前系统时间和⽇期并格式化输出:import java.util.Date;import java.text.SimpleDateFormat;public class NowString {public static void main(String[] args) {SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置⽇期格式System.out.println(df.format(new Date()));// new Date()为获取当前系统时间}}⼆、Date转换为DatetimeDate date = new Date();Timestamp timestamp = new Timestamp(date.getTime()); //2013-01-14 22:45:36.484三、String转换为Date//String转换为java.util.DateString str = "2013-01-14";SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");Date date = null; //初始化datetry {date = sdf.parse(str); //Mon Jan 14 00:00:00 CST 2013} catch (ParseException e) {e.printStackTrace();}四、Date转换为String//java.util.Date转换为StringDate date = new Date();DateFormat format = new SimpleDateFormat("yyyy-MM-dd");String str = format.format(date); //2013-01-14五、String转化为java.sql.Date//String转换为java.sql.DateString str = "2013-01-14";SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");java.sql.Date sdate = null; //初始化try {java.util.Date udate = sdf.parse(str);sdate = new java.sql.Date(udate.getTime()); //2013-01-14} catch (ParseException e) {e.printStackTrace();}六、SimpleDateFormat格式说明G 年代标志符y 年M ⽉d ⽇h 时在上午或下午 (1~12)H 时在⼀天中 (0~23)m 分s 秒S 毫秒E 星期D ⼀年中的第⼏天F ⼀⽉中第⼏个星期⼏w ⼀年中第⼏个星期W ⼀⽉中第⼏个星期a 上午 / 下午标记符k 时在⼀天中 (1~24)K 时在上午或下午 (0~11)z 时区import java.text.*;import java.util.Date;public class FormatDateTime {public static void main(String[] args) {/// 打印出2006年11⽉17⽇ 15时19分56秒SimpleDateFormat myFmt=new SimpleDateFormat("yyyy年MM⽉dd⽇ HH时mm分ss秒");//打印 06/11/17 15:19SimpleDateFormat myFmt1=new SimpleDateFormat("yy/MM/dd HH:mm");//2006-11-17 15:19:56SimpleDateFormat myFmt2=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//2006年11⽉17⽇ 15时19分56秒星期五SimpleDateFormat myFmt3=new SimpleDateFormat("yyyy年MM⽉dd⽇ HH时mm分ss秒 E ");// ⼀年中的第 321 天⼀年中第46个星期⼀⽉中第3个星期在⼀天中15时 CST时区SimpleDateFormat myFmt4=new SimpleDateFormat("⼀年中的第 D 天⼀年中第w个星期⼀⽉中第W个星期在⼀天中k时 z时区");Date now=new Date();System.out.println(myFmt.format(now));System.out.println(myFmt1.format(now));System.out.println(myFmt2.format(now));System.out.println(myFmt3.format(now));System.out.println(myFmt4.format(now));System.out.println(now.toGMTString());// 17 Nov 2006 07:19:56 GMTSystem.out.println(now.toLocaleString());// 2006-11-17 15:19:56System.out.println(now.toString());// Fri Nov 17 15:19:56 CST 2006}}七、将Unix时间戳转换成指定格式⽇期public String TimeStamp2Date(String timestampString, String formats){Long timestamp = Long.parseLong(timestampString)*1000;String date = new java.text.SimpleDateFormat(formats).format(new java.util.Date(timestamp)); return date;}当调⽤TimeStampToDate("1252639886", "yyyy-MM-dd HH:mm:ss");返回值：2009-11-09 11:31:26。

java之时间戳处理●时间戳(timestamp)定义时间戳指的是从格林威治时间1970年01⽉01⽇00时00分00秒起⾄现在的总秒数。

严格来说，不管你处在地球上的哪个地⽅，任意时间点的时间戳都是相同的。

这点有利于线上和客户端分布式应⽤统⼀追踪时间信息。

时间戳是没有时区概念的，同⼀个时间戳对不同时区显⽰的时间不⼀样⽽已。

最近在做⼀个api的⾃测时发现，在不同环境同⼀个api返回的response⾥的时间戳结果不太⼀样。

查看了下编程逻辑，代码如下：SimpleDateFormat sDateFormat = new SimpleDateFormat("yyyy-MM-dd");Date date = sDateFormat.parse(m.getDaytime());//格式类似"2020-02-20"getEventNumDateResponse.setTime(date.getTime());sDateFormat = null; 这段代码逻辑上没什么问题，但在不同环境上运⾏结果不⼀样，问题出在哪了？ 细想，怀疑Date与时区肯定有关系，经过检查，发现本地的时区是默认的东⼋区UTC+0800，本地java 程序运⾏也没配置时区，采⽤的⾃然是系统时区东⼋区，⽽在另外⼀个开发环境，jar包运⾏时配置了-Duser.timezone=UTC，虽然系统默认也是东⼋区，原来是这个设置导致的。

⽐如"2020-02-20"这个字符串时间，被SimpleDateFormat parse后，如果当前的运⾏时区（没设置则是系统时区）是UTC+0800，则时间Date 是：Thu Feb 20 00:00:00 CST 2020 CST时区包含了UTC+8:00 也就是这个时间⾃然是东⼋区的 2020-02-20 00:00:00 这个时间，对应着是UTC 0时区的2020-02-19 16:00:00时间，通过getTime获取的时间戳是：System.out.println(TimeZone.getDefault().getRawOffset());28800000System.out.println(sdf.parse("2020-02-20").getTime());1582128000000通过在pg⾥转化验证：SELECT TO_TIMESTAMP(1582128000)AT TIME ZONE 'UTC-0' ;2020-02-19 16:00:00SELECT TO_TIMESTAMP(1582128000)AT TIME ZONE 'Asia/Shanghai' ;2020-02-20 00:00:00同样，当我们在系统⾥设置了时区为UTC 0时区，或者在jar运⾏时设置了-Duser.timezone=UTC，或者在代码⾥配置了TimeZone.setDefault(TimeZone.getTimeZone("UTC")); 这样，当后⾯SimpleDateFormat parse后，则时间Date是：Thu Feb 20 00:00:00 UTC 2020，表明是UTC 0时区的 2020-02-20 00:00:00 这个时间，对应着是UTC+8时区的2020-02-20 08:00:00时间，通过getTime获取的时间戳是：System.out.println(TimeZone.getDefault().getRawOffset());System.out.println(sdf.parse("2020-02-20").getTime());1582156800000通过在pg⾥转化验证：SELECT TO_TIMESTAMP(1582156800)AT TIME ZONE 'UTC-0' ;2020-02-20 00:00:00----直接写时区偏移(基于格林威治时区，是反的，即提前-滞后+，例如正常东⼋区，需要写-8:00，因此建议直接⽤时区缩写，见后⾯附表，当然也可以写---Asia/Shanghai表⽰东⼋区SELECT TO_TIMESTAMP(1582156800)AT TIME ZONE 'Asia/Shanghai' ;2020-02-20 08:00:00写到这⾥，相信⼤家都明⽩了为啥同⼀个程序在不同机器上跑出的涉及时间戳的结果不⼀致，这⼀点要注意额，千万别掉坑⾥。

timestamp数据类型用法在Java中，timestamp（时间戳）数据类型用于表示特定的日期和时间。

它是一个长整型数值，代表自1970年1月1日00:00:00 GMT以来经过的毫秒数。

timestamp数据类型在处理时间相关操作时非常有用，例如记录事件发生的时间、进行时间戳比较等。

创建timestamp对象要创建一个timestamp对象，可以使用java.sql.Timestamp类。

这个类提供了多个构造函数来创建timestamp对象。

以下是一些常用的创建timestamp对象的方法：// 使用当前系统时间创建timestamp对象Timestamp timestamp = new Timestamp(System.currentTimeMillis());// 使用指定的毫秒数创建timestamp对象Timestamp timestamp = new Timestamp(1000000000);// 使用指定的年、月、日、时、分和秒创建timestamp对象Timestamp timestamp = Timestamp.valueOf("2022-01-01 12:30:45");获取和设置timestamp值要获取一个timestamp对象表示的日期和时间，可以使用getTime()方法，它返回一个long型数值表示从1970年1月1日00:00:00 GMT到该日期和时间经过的毫秒数。

long milliseconds = timestamp.getTime();要设置一个timestamp对象表示的日期和时间，可以使用setTime()方法，它接受一个long型参数表示从1970年1月1日00:00:00 GMT到目标日期和时间经过的毫秒数。

Timestamp timestamp = new Timestamp(0);timestamp.setTime(1000000000);格式化timestamp值要将timestamp对象格式化为特定的日期和时间字符串，可以使用SimpleDateFormat类。