java中时间格式的转换

关于java实体类时间类型的格式化调整问题关于java bean在后台\转化为json交给前台时间类型格式调整的⽅法：1. ⾸先要引⼊fastjson依赖。

2. 在实体类上使⽤注解： @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone = "GMT+8"),这⾥是精确到秒，如果只精确到天，就把上⾯注解的HH:mm:ss去掉。

package com.xjzt.waimai.pojo.weChatUser;import com.fasterxml.jackson.annotation.JsonFormat;import lombok.AllArgsConstructor;import lombok.Data;import lombok.NoArgsConstructor;import org.apache.ibatis.type.Alias;import java.io.Serializable;import java.util.Date;@Data@AllArgsConstructor@NoArgsConstructor@Alias("weCharUser")public class WeCharUser implements Serializable {private String openId;private String nickName;private String gender;private String province;private String city;@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")private Date createTime;@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")private Date lastVisitTime;}。

java时分的正则表达式Java时分的正则表达式正则表达式是一种描述字符串模式的语法，可以用来匹配、查找和替换文本中的字符。

在Java中，可以使用正则表达式对字符串进行各种操作，如验证邮箱格式、提取手机号码、判断字符串是否为数字等。

本文将介绍Java中常用的时分正则表达式，并解释其用法和示例。

一、匹配时间格式的正则表达式1. 匹配24小时制的时间格式：HH:mm:ss正则表达式：^[0-2][0-9]:[0-5][0-9]:[0-5][0-9]$示例：12:34:562. 匹配12小时制的时间格式：hh:mm:ss am/pm正则表达式：^(0[1-9]|1[0-2]):[0-5][0-9]:[0-5][0-9] (am|pm)$示例：09:45:30 am3. 匹配小时和分钟的时间格式：HH:mm正则表达式：^[0-2][0-9]:[0-5][0-9]$示例：20:154. 匹配12小时制的小时和分钟的时间格式：hh:mm am/pm正则表达式：^(0[1-9]|1[0-2]):[0-5][0-9] (am|pm)$示例：03:30 pm二、使用正则表达式的示例代码1. 验证时间格式是否正确：```javapublic boolean isValidTimeFormat(String time) {String regex = "^[0-2][0-9]:[0-5][0-9]:[0-5][0-9]$"; return time.matches(regex);}```2. 提取时间字符串中的小时和分钟：```javapublic String extractHourAndMinute(String time) { String regex = "^(\\d{2}):(\\d{2}):(\\d{2})$";Pattern pattern = pile(regex);Matcher matcher = pattern.matcher(time);if (matcher.find()) {String hour = matcher.group(1);String minute = matcher.group(2);return hour + ":" + minute;}return null;}```三、注意事项和常见问题1. 在使用正则表达式时，需要使用Java的转义字符，如\需要写成\\。

date类型转年月日格式如何将日期类型转换为年月日格式[导语]日期类型是编程中常见的一种数据类型，它表示一个特定的日期和时间。

在某些情况下，我们需要将日期类型转换为特定的格式，例如年月日格式。

本文将为您介绍如何一步步将日期类型转换为年月日格式。

[第一步：了解日期类型]在开始转换之前，我们需要先了解日期类型。

常见的日期类型有Date、DateTime和Timestamp。

在不同的编程语言中，日期类型的表示方式可能会有些差异。

在本文中，我们以Java为例进行讲解。

在Java中，日期类型通常使用java.util.Date类来表示。

[第二步：获取日期类型对象]要进行日期格式转换，首先我们需要获得一个日期类型的对象。

可以通过不同的方式来获取日期类型对象。

例如，可以使用系统的当前日期和时间来创建一个新的日期对象，或者从数据库中获取日期类型的数据。

下面是一个示例代码，演示如何获取一个日期类型对象：javaimport java.util.Date;public class DateConversionExample {public static void main(String[] args) {Date currentDate = new Date();System.out.println("当前日期和时间：" + currentDate);}}在这个示例中，我们使用了java.util.Date类的无参构造方法创建了一个新的日期对象currentDate，并通过System.out.println()方法将其打印出来。

通过运行这段代码，我们可以获取到当前的日期和时间。

[第三步：格式化日期类型]获取到日期类型对象后，我们可以使用SimpleDateFormat类来对日期进行格式化。

SimpleDateFormat是Java中常用的日期格式化类，它提供了多种格式化模式，可以根据需要选择不同的模式来转换日期格式。

java2个时间格式间转换（原创实用版）目录1.Java 中时间格式的表示2.时间格式的转换方法3.具体转换实例正文在 Java 编程语言中，时间格式的表示主要依赖于`java.time`包中的`LocalDateTime`和`ZonedDateTime`类。

这两个类分别用于表示不带时区的本地日期时间以及带时区的日期时间。

在实际编程中，我们常常需要对这些时间格式进行转换。

接下来，我们就来学习一下如何在 Java 中进行时间格式的转换。

一、Java 中时间格式的表示在 Java 中，时间格式主要通过`DateTimeFormatter`类进行表示。

`DateTimeFormatter`类提供了一系列的静态方法，用于创建不同格式的日期时间表示。

例如，我们可以使用`DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")`创建一个表示“年 - 月-日时：分:秒”的格式。

二、时间格式的转换方法在 Java 中，我们可以通过`DateTimeFormatter`类的`parse()`和`format()`方法进行时间格式的转换。

`parse()`方法用于将字符串格式的时间转换为`LocalDateTime`或`ZonedDateTime`对象，而`format()`方法则用于将`LocalDateTime`或`ZonedDateTime`对象转换为字符串格式的时间。

以下是一个简单的转换实例：```javaimport java.time.LocalDateTime;import java.time.ZoneId;import java.time.format.DateTimeFormatter;public class TimeFormatConversion {public static void main(String[] args) {// 创建一个表示“年 - 月-日时：分:秒”的DateTimeFormatterDateTimeFormatter formatter =DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");// 定义一个字符串格式的时间String dateTimeStr = "2022-01-01 12:30:45";// 使用 parse() 方法将字符串格式的时间转换为LocalDateTime 对象LocalDateTime localDateTime =LocalDateTime.parse(dateTimeStr, formatter);// 使用 format() 方法将 LocalDateTime 对象转换为字符串格式的时间String convertedDateTimeStr =localDateTime.format(formatter);// 输出转换后的时间System.out.println("转换后的时间：" + convertedDateTimeStr);}}```三、具体转换实例以下是一个具体的转换实例，演示如何将一个表示“年 - 月-日时：分:秒”的时间格式转换为“时分：秒.毫秒”格式：```javaimport java.time.LocalDateTime;import java.time.format.DateTimeFormatter;public class TimeFormatConversion {public static void main(String[] args) {// 创建一个表示“年 - 月-日时：分:秒”的DateTimeFormatterDateTimeFormatter formatter =DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");// 定义一个字符串格式的时间String dateTimeStr = "2022-01-01 12:30:45";// 使用 parse() 方法将字符串格式的时间转换为LocalDateTime 对象LocalDateTime localDateTime =LocalDateTime.parse(dateTimeStr, formatter);// 使用 format() 方法将 LocalDateTime 对象转换为字符串格式的时间String convertedDateTimeStr =localDateTime.format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS" ));// 输出转换后的时间System.out.println("转换后的时间：" + convertedDateTimeStr);}}```运行上述代码，输出结果为：```转换后的时间：12:30:45.000```以上就是 Java 中时间格式间转换的相关知识。

java 国际标准时间字符串转换-回复如何将国际标准时间字符串转换为其他格式的时间表示方式。

这篇文章将从最基本的概念开始，逐步解释如何进行转换，并提供实际的示例来帮助读者理解和应用这些概念。

首先，我们来了解一下国际标准时间的概念。

国际标准时间（简称UTC）是一种使用的全球标准时间，用于统一不同地区的时间表示方式。

它基于原子钟的测量结果，具有高度的精确性和可靠性。

国际标准时间通常以24小时制的方式表示，格式为hh:mm:ss。

例如，13:30:00表示下午1点30分。

现在假设我们有一个国际标准时间字符串"09:45:30"，我们想将其转换为其他格式的时间表示方式，例如12小时制的时间、时间戳等等。

下面是一步一步的解释：1. 将字符串解析为时间对象：首先，我们需要将国际标准时间字符串解析为程序能够理解的时间对象。

在Java中，可以使用SimpleDateFormat 类来完成这个任务。

以下是一个示例代码：javaString timeString = "09:45:30";SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");Date time = sdf.parse(timeString);在这个示例中，我们使用SimpleDateFormat来定义一个格式为"HH:mm:ss"的时间模板，然后将时间字符串解析为一个Date对象。

2. 转换为12小时制的时间表示方式：如果我们想将时间表示为12小时制的方式，我们需要使用另一个时间格式模板"hh:mm:ss a"。

以下是一个示例代码：javaSimpleDateFormat sdf12 = new SimpleDateFormat("hh:mm:ss a"); String time12 = sdf12.format(time);System.out.println(time12);在这个示例中，我们创建了另一个SimpleDateFormat对象，使用"hh:mm:ss a"作为时间格式模板。

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));二、时间戳的概念和作用时间戳是指计算机系统自动生成的一个序列号，用于记录时间的起始点。

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

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

return ctime;
}
public static String getWeek(){
SimpleDateFormat formatter;
formatter = new SimpleDateFormat ("E");
String ctime = formatter.format(new Date());
}
/**
* 将java.util.Date 格式转换为字符串格式'yyyy-MM-dd HH:mm:ss a'(12小时制)<br>
* 如Sat May 11 17:23:22 CST 2002 to '2002-05-11 05:23:22 下午'<br>
* @param time Date 日期<br>
* 如Sat May 11 17:24:21 CST 2002 to '2002-05-11 17:24:21'<br>
* @param time Date 日期<br>
* @return String 字符串<br>
*/
public static String dateToString(Date time){
return ctime;
}
public static String getDay(){
SimpleDateFormat formatter;
formatter = new SimpleDateFormat ("d");
String ctime = formatter.format(new Date());

java 国际标准时间字符串转换在Java编程中，我们经常需要将日期和时间从一种格式转换为另一种格式。

特别是当我们需要与国际标准时间（UTC）进行交互时，我们经常需要将本地时间转换为UTC时间。

在Java中，可以使用java.time包中的类来进行这种转换。

一、背景介绍Java8引入了新的日期和时间API，即java.time包。

这个包提供了简单易用的API来处理日期和时间。

它包括LocalDate、LocalTime、LocalDateTime、ZonedDateTime等类，可以方便地处理各种日期和时间相关的操作。

二、问题阐述在Java应用程序中，我们经常需要将本地时间转换为国际标准时间（UTC）。

例如，当与远程服务器进行通信时，我们需要将本地时间转换为UTC时间以便正确处理时间戳。

此外，在处理跨时区的数据时，也需要进行这样的转换。

三、解决方案为了将本地时间转换为国际标准时间（UTC），我们可以使用java.time包中的ZonedDateTime类和DateTimeFormatter类。

ZonedDateTime类提供了当前的日期和时间以及所在的时区信息。

通过将它转换为没有时区信息的ZonedDateTime对象，我们就可以得到相应的UTC时间。

以下是一个示例代码：```javaimportjava.time.ZoneId;importjava.time.ZonedDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前本地时间ZoneIdlocalZone=ZoneId.of("Asia/Shanghai");//替换为你的本地时区ZonedDateTimelocalDateTime=ZonedDateTime.now(localZone);System.out.println("Localtime:"+localDateTime);//将本地时间转换为UTC时间ZoneIdutcZone=ZoneId.of("Z");//Z代表UTC时区ZonedDateTimeutcDateTime=localDateTime.withZoneSameInstan t(utcZone);System.out.println("UTCtime:"+utcDateTime);}}```在这个示例中，我们首先获取了当前本地时间，并将其存储在ZonedDateTime对象中。

java中各种时间格式的转化时间和日期中常用到的几个类：java.util.Date,java.util.Calendar,java.util.GregorainCalendar,java.text.DateFormat,java.text.SimpleDateFormatjava.util.Date :表示特定瞬间,精确到毫秒一天是24 * 60 * 60 = 86400 秒世界时(UT 或UTC) , 格林威治时间(GMT), 格林威治时(GMT)和世界时(UT)是相等的，格林威治时(GMT) 是标准的"民间"称呼, 世界时(UT) 是相同标准的科学称呼。

UTC 和UT 的区别是：UTC 是基于原子时钟的，UT 是基于天体观察的。

(中文版的jdk 真是好啊，跟科普教材是的，呵呵)常用的构造方法:Date();Date(long date)(long date) 表示从标准基准时间（称为"历元" epoch ，即1970.1.100:00:00 GMT）经历的毫秒数。

还有一些构造方法已经deprecated 了主要的方法：（介绍几个常用的，详细的查询jdk 文档）boolean after(Date when) 测试日期在此日期之后。

boolean before(Date when) 测试日期在此日期之前。

Object clone() 返回此对象的副本long getTime() 返回自1970.1.1 00:00:00 GMT 后，此对象表示的毫秒数void setTime(long time) 设置此Date 对象，以表示1970 年1 月1 日00:00:00 GMT 以后time 毫秒的时间点。

String toString() 将Date 对象转化成以下形式的String：dow mon dd hh:mm:ss zzz yyyy其中：dow 是一周中的某一天(Sun, Mon, Tue, Wed, Thu, Fri, Sat)。

Java8中时间的字符串和Long时间戳互转1、取当前时间戳Long millisecond = Instant.now().toEpochMilli(); // 精确到毫秒Long second = Instant.now().getEpochSecond();// 精确到秒2、将Long类型的时间戳转成字符串/*** 将Long类型的时间戳转换成String 类型的时间格式，时间格式为：yyyy-MM-dd HH:mm:ss*/public static String timeToString(Long time){Assert.notNull(time, "time is null");DateTimeFormatter ftf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");return ftf.format(LocalDateTime.ofInstant(Instant.ofEpochMilli(time),ZoneId.systemDefault()));}3、时间字符串转成Long类型的时间戳/*** 将字符串转⽇期成Long类型的时间戳，格式为：yyyy-MM-dd HH:mm:ss*/public static Long timeToLong(String time) {Assert.notNull(time, "time is null");DateTimeFormatter ftf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");LocalDateTime parse = LocalDateTime.parse("2019-11-28 08:52:50", ftf);return LocalDateTime.from(parse).atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();}4、时间转换Utils/*** 将Long类型的时间戳转换成String 类型的时间格式，时间格式为：yyyy-MM-dd HH:mm:ss*/public static String timeToString(Long time, String format){Assert.notNull(time, "time is null");// "yyyy-MM-dd HH:mm:ss"DateTimeFormatter formatString = DateTimeFormatter.ofPattern(format);return formatString.format(LocalDateTime.ofInstant(Instant.ofEpochMilli(time), ZoneId.systemDefault()));}/*** 将字符串转⽇期成Long类型的时间戳，格式为：yyyy-MM-dd HH:mm:ss*/public static Long timeToLong(String time) {Assert.notNull(time, "time is null");DateTimeFormatter formatString = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");LocalDateTime parse = LocalDateTime.parse("2019-11-28 08:52:50", formatString);return LocalDateTime.from(parse).atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();}/*** localDate 格式化*/public static String localDateFormat(LocalDate localDate, String format){Assert.notNull(localDate, "time is null");// "yyyy-MM-dd HH:mm:ss"String localDateStr = DateTranslate.timeToString(localDate2Second(localDate), format);return localDateStr;}/*** localDate 格式化*/public static String localDateTimeFormat(LocalDateTime localDateTime, String format){Assert.notNull(localDateTime, "time is null");// "yyyy-MM-dd HH:mm:ss"String localDateTimeStr = DateTranslate.timeToString(localDateTime2Second(localDateTime), format);return localDateTimeStr;}/*** 取本⽉第⼀天*/public static LocalDate firstDayOfThisMonth() {LocalDate today = LocalDate.now();return today.with(TemporalAdjusters.firstDayOfMonth());}/*** 取本⽉第⼀天*/public static LocalDate firstDayOfLastMonth() {LocalDate today = LocalDate.now();today = today.minusMonths(1);return today.with(TemporalAdjusters.firstDayOfMonth());}/*** 取本⽉第N天*/public static LocalDate dayOfThisMonth(int n) {LocalDate today = LocalDate.now();return today.withDayOfMonth(n);}/*** 取本⽉最后⼀天*/public static LocalDate lastDayOfThisMonth() {LocalDate today = LocalDate.now();return today.with(stDayOfMonth());}/*** 获取本周⼀*/public static LocalDateTime firstDayOfWeek(Long date) {// long转LocalDateTimeLocalDateTime localDateTime = LocalDateTime.ofInstant(Instant.ofEpochMilli(date), ZoneId.systemDefault());return localDateTime.with(DayOfWeek.MONDAY);}/*** 获取上周⼀*/public static LocalDateTime firstDayOfLastWeek(Long date) {// long转LocalDateTimeLocalDateTime localDateTime = LocalDateTime.ofInstant(Instant.ofEpochMilli(date), ZoneId.systemDefault());LocalDateTime localDateTime1 = localDateTime.plusDays(-7);return localDateTime1.with(DayOfWeek.MONDAY);}/*** 获取上周⼀*/public static LocalDateTime lastDay(Long date) {// long转LocalDateTimeLocalDateTime localDateTime = LocalDateTime.ofInstant(Instant.ofEpochSecond(date), ZoneId.systemDefault()); LocalDateTime localDateTime1 = localDateTime.plusDays(-1);return localDateTime1;}/*** 取本⽉第⼀天的开始时间*/public static LocalDateTime startOfThisMonth() {return LocalDateTime.of(firstDayOfThisMonth(), LocalTime.MIN);}/*** 取本⽉最后⼀天的结束时间*/public static LocalDateTime endOfThisMonth() {return LocalDateTime.of(lastDayOfThisMonth(), LocalTime.MAX);}/** LocalDate转时间戳 */public static Long localDate2Second(LocalDate localDate) {return LocalDateTime.of(localDate, LocalTime.MIN).toInstant(ZoneOffset.ofHours(8)).getEpochSecond();}/** LocalDate转时间戳 */public static Long localDateTime2Second(LocalDateTime localDateTime) {return localDateTime.toEpochSecond(ZoneOffset.of("+8"));}java 8 Localdate常⽤API====================================正确答案==================================getYear() int获取当前⽇期的年份getMonth() Month 获取当前⽇期的⽉份对象getMonthValue() int获取当前⽇期是第⼏⽉getDayOfWeek() DayOfWeek 表⽰该对象表⽰的⽇期是星期⼏getDayOfMonth() int表⽰该对象表⽰的⽇期是这个⽉第⼏天getDayOfYear() int表⽰该对象表⽰的⽇期是今年第⼏天withYear(int year) LocalDate 修改当前对象的年份withMonth(int month) LocalDate 修改当前对象的⽉份withDayOfMonth(int dayOfMonth) LocalDate 修改当前对象在当⽉的⽇期isLeapYear() boolean是否是闰年lengthOfMonth() int这个⽉有多少天lengthOfYear() int该对象表⽰的年份有多少天（365或者366）plusYears(long yearsToAdd) LocalDate 当前对象增加指定的年份数plusMonths(long monthsToAdd) LocalDate 当前对象增加指定的⽉份数plusWeeks(long weeksToAdd) LocalDate 当前对象增加指定的周数plusDays(long daysToAdd) LocalDate 当前对象增加指定的天数minusYears(long yearsToSubtract) LocalDate 当前对象减去指定的年数minusMonths(long monthsToSubtract) LocalDate 当前对象减去注定的⽉数minusWeeks(long weeksToSubtract) LocalDate 当前对象减去指定的周数minusDays(long daysToSubtract) LocalDate 当前对象减去指定的天数compareTo(ChronoLocalDate other) int⽐较当前对象和other对象在时间上的⼤⼩，返回值如果为正，则当前对象时间较晚，isBefore(ChronoLocalDate other) boolean⽐较当前对象⽇期是否在other对象⽇期之前isAfter(ChronoLocalDate other) boolean⽐较当前对象⽇期是否在other对象⽇期之后isEqual(ChronoLocalDate other) boolean⽐较两个⽇期对象是否相等。

java中国标准时间转换yymmdd方法在Java编程中，我们经常需要进行日期和时间的转换和处理。

其中一个常见的需求是将中国标准时间（CST）转换为一个特定的格式，比如yymmdd（年份的后两位+月份+日期）。

下面是一种Java方法，可以用来实现这个转换。

```javaimport java.text.SimpleDateFormat;import java.util.Date;import java.util.TimeZone;public class CSTConverter {public static String convertToYYMMDD(Date date) {// 设置时区为中国（东八区）TimeZone cstTimezone = TimeZone.getTimeZone("Asia/Shanghai");SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");dateFormat.setTimeZone(cstTimezone);// 将传入的日期对象按照指定格式进行格式化String convertedDate = dateFormat.format(date);// 返回转换后的字符串return convertedDate;}public static void main(String[] args) {// 测试示例Date current = new Date();String convertedDate = convertToYYMMDD(current);System.out.println("当前日期转换后的结果为：" + convertedDate);}}```在上述代码中，我们使用了`SimpleDateFormat`类来指定日期格式，并使用`TimeZone`类来设置时区为中国（东八区）。

Java时间⽇期格式转换Date转String和String转Date 1 Java时间格式转换⼤全23import java.text.*;4import java.util.Calendar;5public class VeDate {6/**7* 获取现在时间8*9* @return返回时间类型 yyyy-MM-dd HH:mm:ss10*/11public static Date getNowDate() {12 Date currentTime = new Date();13 SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");14 String dateString = formatter.format(currentTime);15 ParsePosition pos = new ParsePosition(8);16 Date currentTime_2 = formatter.parse(dateString, pos);17return currentTime_2;18 }19/**20* 获取现在时间21*22* @return返回短时间格式 yyyy-MM-dd23*/24 DateFormat format1 = new SimpleDateFormat("yyyy-MM-dd");25 DateFormat format 2= new SimpleDateFormat("yyyy年MM⽉dd⽇ HH时mm分ss秒");26 Date date = null;27 String str = null;2829// String转Date30 str = "2007-1-18";31try {32 date = format1.parse(str);33 data = format2.parse(str);34 } catch (ParseException e) {35 e.printStackTrace();36 }37/**38* 获取现在时间39*40* @return返回字符串格式 yyyy-MM-dd HH:mm:ss41*/42public static String getStringDate() {43 Date currentTime = new Date();44 SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");45 String dateString = formatter.format(currentTime);46return dateString;47 }48/**49* 获取现在时间50*51* @return返回短时间字符串格式yyyy-MM-dd52*/53public static String getStringDateShort() {54 Date currentTime = new Date();55 SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");56 String dateString = formatter.format(currentTime);57return dateString;58 }59/**60* 获取时间⼩时:分;秒 HH:mm:ss61*62* @return63*/64public static String getTimeShort() {65 SimpleDateFormat formatter = new SimpleDateFormat("HH:mm:ss");66 Date currentTime = new Date();67 String dateString = formatter.format(currentTime);68return dateString;69 }70/**71* 将长时间格式字符串转换为时间 yyyy-MM-dd HH:mm:ss72*73* @param strDate74* @return75*/76public static Date strToDateLong(String strDate) {77 SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");81 }82/**83* 将长时间格式时间转换为字符串 yyyy-MM-dd HH:mm:ss84*85* @param dateDate86* @return87*/88public static String dateToStrLong(java.util.Date dateDate) {89 SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");90 String dateString = formatter.format(dateDate);91return dateString;92 }93/**94* 将短时间格式时间转换为字符串 yyyy-MM-dd95*96* @param dateDate97* @param k98* @return99*/100public static String dateToStr(java.util.Date dateDate) {101 SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");102 String dateString = formatter.format(dateDate);103return dateString;104 }105/**106* 将短时间格式字符串转换为时间 yyyy-MM-dd107*108* @param strDate109* @return110*/111public static Date strToDate(String strDate) {112 SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");113 ParsePosition pos = new ParsePosition(0);114 Date strtodate = formatter.parse(strDate, pos);115return strtodate;116 }117/**118* 得到现在时间119*120* @return121*/122public static Date getNow() {123 Date currentTime = new Date();124return currentTime;125 }126/**127* 提取⼀个⽉中的最后⼀天128*129* @param day130* @return131*/132public static Date getLastDate(long day) {133 Date date = new Date();134long date_3_hm = date.getTime() - 3600000 * 34 * day;135 Date date_3_hm_date = new Date(date_3_hm);136return date_3_hm_date;137 }138/**139* 得到现在时间140*141* @return字符串 yyyyMMdd HHmmss142*/143public static String getStringToday() {144 Date currentTime = new Date();145 SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd HHmmss"); 146 String dateString = formatter.format(currentTime);147return dateString;148 }149/**150* 得到现在⼩时151*/152public static String getHour() {153 Date currentTime = new Date();154 SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 155 String dateString = formatter.format(currentTime);156 String hour;157 hour = dateString.substring(11, 13);158return hour;159 }160/**161* 得到现在分钟165public static String getTime() {166 Date currentTime = new Date();167 SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");168 String dateString = formatter.format(currentTime);169 String min;170 min = dateString.substring(14, 16);171return min;172 }173/**174* 根据⽤户传⼊的时间表⽰格式，返回当前时间的格式如果是yyyyMMdd，注意字母y不能⼤写。

Java前后端时间格式的转化⽅式JsonFormat、DateTimeFormat使⽤从数据库获取时间传到前端进⾏展⽰的时候，我们有时候可能⽆法得到⼀个满意的时间格式的时间⽇期，在数据库中显⽰的是正确的时间格式，获取出来却变成了很丑的时间戳，@JsonFormat注解很好的解决了这个问题，我们通过使⽤@JsonFormat 可以很好的解决：后台到前台时间格式保持⼀致的问题。

其次，另⼀个问题是，我们在使⽤WEB服务的时，可能会需要⽤到，传⼊时间给后台，⽐如注册新⽤户需要填⼊出⽣⽇期等，这个时候前台传递给后台的时间格式同样是不⼀致的，⽽我们的与之对应的便有了另⼀个注解，@DataTimeFormat便很好的解决了这个问题，接下来记录⼀下具体的@JsonFormat与DateTimeFormat的使⽤过程。

@JsonFormat导⼊依赖<dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-annotations</artifactId><version>2.8.8</version></dependency><dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-databind</artifactId><version>2.8.8</version></dependency><dependency><groupId>org.codehaus.jackson</groupId><artifactId>jackson-mapper-asl</artifactId><version>1.9.13</version></dependency>在你需要查询出来的时间的数据库字段对应的实体类的属性上添加 @JsonFormat@Data@Api("升级⽇志返回值")public class UpgradeLogRes {@ApiModelProperty("升级⽇志id")private Long id;@ApiModelProperty("版本名称")private String name;@ApiModelProperty("发布⽇期")@JsonFormat(pattern = "yyyy-MM-dd")private Date postDate;@ApiModelProperty("内容⽇志")private String contentLog;@ApiModelProperty("发布状态")private Integer postStatus;@ApiModelProperty("内容⽇志Url")private String contentLogUrl;}注：@JsonFormat(pattern=“yyyy-MM-dd”,timezone = “GMT+8”)pattern：是你需要转换的时间⽇期的格式timezone：是时间设置为东⼋区，避免时间在转换中有误差提⽰：@JsonFormat注解可以在属性的上⽅，同样可以在属性对应的get⽅法上，两种⽅式没有区别@DateTimeFormat导⼊依赖：@DateTimeFormat的使⽤和@jsonFormat差不多，⾸先需要引⼊是spring还有jodatime,spring我就不贴了<dependency><groupId>joda-time</groupId><artifactId>joda-time</artifactId><version>2.3</version></dependency>在controller层我们使⽤spring mvc 表单⾃动封装映射对象时，我们在对应的接收前台数据的对象的属性上加@DateTimeFormat@DateTimeFormat(pattern = "yyyy-MM-dd")@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone="GMT+8")private Date symstarttime;@DateTimeFormat(pattern = "yyyy-MM-dd")@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone="GMT+8")private Date symendtime;我这⾥就只贴这两个属性了，这⾥我两个注解都同时使⽤了，因为我既需要取数据到前台，也需要前台数据传到后台，都需要进⾏时间格式的转换，可以同时使⽤总结⼀下：注解@JsonFormat主要是后台到前台的时间格式的转换注解@DataFormAT主要是前后到后台的时间格式的转换java前后端Date接收1.前端传Date对象将其转为“yyyy-MM-dd HH:mm:ss”的字符串，后台⽤@DateTimeFormat(pattern=“yyyy-MM-dd HH:mm:ss”)格式化Date属性2.后台返回给前端Date传的是时间戳，⽤@JsonFormat(pattern = “yyyy-MM-dd HH:mm:ss”, timezone = “GMT+8”)对其格式化，timezone是⽤于调整时区的属性(东⼋区)，不加的话得到的时间会⽐实际的少8个⼩时@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")private Date startTime;3.时间⽐较：mybaties :startTime, endTime是经过@DateTimeFormat格式后的Date对象<if test="startTime != null">and alarm.createTime &gt;= #{startTime}</if><if test="endTime != null">and alarm.createTime &lt;= #{endTime}</if>以上为个⼈经验，希望能给⼤家⼀个参考，也希望⼤家多多⽀持。

Java 日期时间Date类型,long类型,String类型表现形式的转换1、java.util.Date类型转换成long类型java.util.Date dt = new Date();System.out.println(dt.toString()); //java.util.Date的含义long lSysTime1 = dt.getTime() / 1000; //得到秒数，Date类型的getTime()返回毫秒数java.util.Date dt = new Date();System.out.println(dt.toString()); //java.util.Date的含义long lSysTime1 = dt.getTime() / 1000; //得到秒数，Date类型的getTime()返回毫秒数2、由long类型转换成Date类型SimpleDateFormat sdf= new SimpleDateFormat("MM/dd/yyyy HH:mm:ss");//前面的lSysTime是秒数，先乘1000得到毫秒数，再转为java.util.Date 类型java.util.Date dt = new Date(lSysTime1 * 1000);String sDateTime = sdf.format(dt); //得到精确到秒的表示：08/31/200621:08:00System.out.println(sDateTime);SimpleDateFormat sdf= new SimpleDateFormat("MM/dd/yyyy HH:mm:ss");//前面的lSysTime是秒数，先乘1000得到毫秒数，再转为java.util.Date 类型java.util.Date dt = new Date(lSysTime1 * 1000);String sDateTime = sdf.format(dt); //得到精确到秒的表示：08/31/2006 21:08:00System.out.println(sDateTime);//注意HH与hh含认不同，HH表示以24小时制取，hh表示以12小时制取常用的格式的含义，摘自Jdk，注意大小写的含义通常是不同的：3、"08/31/2006 21:08:00"格式的String转换java.util.Date类型String sDt = "08/31/2006 21:08:00";SimpleDateFormat sdf= new SimpleDateFormat("MM/dd/yyyy HH:mm:ss");Date dt2 = sdf.parse(sDt);//继续转换得到秒数的long型long lTime = dt2.getTime() / 1000;String sDt = "08/31/2006 21:08:00";SimpleDateFormat sdf= new SimpleDateFormat("MM/dd/yyyy HH:mm:ss");Date dt2 = sdf.parse(sDt);//继续转换得到秒数的long型long lTime = dt2.getTime() / 1000;//注意HH与hh含认不同，HH表示以24小时制取，hh表示以12小时制取常用的格式的含义，摘自Jdk，注意大小写的含义通常是不同的：字母含义示例y Y ear 1996;96 哪一年M Month in year J uly;Jul;07 一年中的哪一月m Minute in hour 30 一个小时中的第几分钟w Week in year 27 一年中的第几个星期W Week in month 2 一个月中的第几个星期D Day in year 189 一年中的第几天d Day in month 10 一个月中的第几天H Hour in day (0-23) 0 一天中的第几个小时（24小时制）h Hour in am/pm (1-12) 12 一天中上午、下午的第几个小时（12小时制）S Millisecond 978 毫秒数s Second in minute 55 一分钟的第几秒字母含义示例y Y ear 1996;96 哪一年M Month in year J uly;Jul;07 一年中的哪一月m Minute in hour 30 一个小时中的第几分钟w Week in year 27 一年中的第几个星期W Week in month 2 一个月中的第几个星期D Day in year 189 一年中的第几天d Day in month 10 一个月中的第几天H Hour in day (0-23) 0 一天中的第几个小时（24小时制）h Hour in am/pm (1-12) 12 一天中上午、下午的第几个小时（12小时制）S Millisecond 978 毫秒数s Second in minute 55 一分钟的第几秒4、系统当前时间long lSysTime2 = System.currentTimeMillis(); //得到毫秒表示的系统当前时间long lSysTime2 = System.currentTimeMillis(); //得到毫秒表示的系统当前时间。

JAVA⽇期格式转换SimpleDateFormat使⽤String转DateString STANDARD_DATE_FORMAT_UTC = "";//设置⽇期时间格式SimpleDateFormat simpleDateFormat = new SimpleDateFormat(STANDARD_DATE_FORMAT);//创建⽇期时间模板String formatStr = "",//拿到与STANDARD_DATE_FORMAT_UTC⼀样的时间字符串Date date = new Date();date = simpleDateFormat.parse(formatStr);//根据模板把字符串转换成标准Date();Date类型转StringString STANDARD_DATE_FORMAT_UTC = "";//设置⽇期时间格式SimpleDateFormat simpleDateFormat = new SimpleDateFormat(STANDARD_DATE_FORMAT);//创建⽇期时间模板Date date = new Date();//拿到⼀个⽇期类型的值String str = "";str = simpleDateFormat.format(date);//根据模板把时间格式转换成特定格式的字符串⽰例：(yyyy-MM-dd'T'HH:mm:ss.SSS'Z')String STANDARD_DATE_FORMAT_UTC = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'";SimpleDateFormat sdf_input = new SimpleDateFormat(STANDARD_DATE_FORMAT_UTC);//输⼊格式String str=inMap.get("createDate").toString();sdf_input.setTimeZone(TimeZone.getTimeZone("GMT"));try {Date date = sdf_input.parse(str);epStaff.setCreateDate(str);}catch (Exception e){System.out.println(e);}Mybatis将⽇期时间格式数据持久到数据库中通常⽤到的util包中的Date()类型在持久到数据库中时会报⽆法转换的错误，要使⽤new java.sql.Date(date.getTime());java.sql包下给出三个与数据库相关的⽇期时间类型，分别是：Date：表⽰⽇期，只有年⽉⽇，没有时分秒。

java中localdatetime转date几种方法-回复如何在Java中将LocalDateTime转换为Date——几种方法Introduction:在Java编程中，我们经常需要在LocalDateTime和Date之间进行转换。

LocalDateTime是Java 8引入的新类，用于表示一个不可变的日期时间对象。

而Date则是Java早期版本中用于表示日期和时间的类。

因此，当我们需要在新旧版本之间进行数据转换时，就需要对它们进行互相转换。

在本文中，我们将一步一步介绍如何使用几种方法将LocalDateTime转换为Date。

方法一：使用java.util.Date的from()方法java.util.Date类提供了一个静态方法from()，可以从Instant对象创建一个Date对象。

因为LocalDateTime没有提供直接转换为Instant对象的方法，所以我们首先需要将LocalDateTime转换为ZonedDateTime对象，然后再将其转换为Instant对象，最后使用from()方法创建Date对象。

下面是具体的代码示例：javaimport java.time.LocalDateTime;import java.time.ZoneId;import java.time.ZonedDateTime;import java.util.Date;public class LocalDateTimeToDateConverter {public static void main(String[] args) {LocalDateTime localDateTime = LocalDateTime.now();ZonedDateTime zonedDateTime =localDateTime.atZone(ZoneId.systemDefault());Instant instant = zonedDateTime.toInstant();Date date = Date.from(instant);System.out.println("LocalDateTime: " + localDateTime);System.out.println("Date: " + date);}}在上述代码中，我们首先获取当前的LocalDateTime对象。

java对‎世界各个时‎区(Tim‎e Zone‎)的通用转‎换处理方法‎.‎在进行国际‎性软件项目‎开发的过程‎中，有时候‎会碰到一些‎比较特殊的‎要求。

比如‎：比如说，‎你做的是个‎购物网站（‎假设服务器‎放在中国上‎海），当全‎世界客户在‎你的网站上‎下订单买东‎西后，往往‎希望看到客‎户所在地下‎单时间，比‎如说我是个‎美国纽约人‎，我在你的‎网站上下单‎后，你给我‎看到一个上‎海的下单时‎间，会觉得‎非常的奇怪‎。

众所周知‎，纽约时间‎相对上海时‎间大约要晚‎13小时，‎如果让客户‎看到本地时‎区的时间，‎将变得更加‎符合客户的‎时间观念，‎使得客户理‎解比较方便‎。

其‎实，jav‎a中早已考‎虑过世界时‎区(Tim‎e Zone‎)这个问题‎，并给出了‎比较合理的‎解决方法，‎可以比较方‎便的进行世‎界时区时间‎的转化，将‎一个时区的‎时间转换成‎另一个时区‎的时间。

可‎以看看下面‎的的实际例‎子（运行例‎子的mai‎n()方法‎）。

‎关于如何知‎道客户所在‎的时区，可‎以根据客户‎所在的ip‎或者用户注‎册提供的国‎家来计算出‎所在的时区‎。

‎Java‎代码 0‎1./* ‎02.‎* Cr‎e ated‎on 2‎005-6‎-10 ‎03. ‎* Aut‎h or s‎t ephe‎n0‎4. * ‎E mail‎zhou‎j ianq‎i ang ‎A T gm‎a il D‎O T co‎m0‎5. * ‎C opyR‎i ght(‎C)200‎5-200‎8 , A‎l l ri‎g hts ‎r eser‎v ed. ‎06.‎*/ ‎07.p‎a ckag‎e com‎.soft‎4j.ut‎i lity‎;‎08. ‎09.i‎m port‎java‎.text‎.Pars‎e Exce‎p tion‎;‎10.im‎p ort ‎j ava.‎t ext.‎S impl‎e Date‎F orma‎t; ‎11.i‎m port‎java‎.util‎.Date‎;‎12.im‎p ort ‎j ava.‎u til.‎G rego‎r ianC‎a lend‎a r; ‎13.‎i mpor‎t jav‎a.uti‎l.Tim‎e Zone‎;‎14.im‎p ort ‎j ava.‎u til.‎V ecto‎r; ‎15. ‎16.‎i mpor‎t com‎.soft‎4j.lo‎g.Log‎;‎17. ‎18./‎**‎19. *‎与日期、‎时间相关的‎一些常用工‎具方法. ‎20.‎* <p‎>2‎1. * ‎日期(时间‎)的常用格‎式(for‎m ater‎)主要有:‎<br>‎22‎. * y‎y yy-M‎M-dd ‎H H:mm‎:ss <‎b r> ‎23. ‎*‎24. *‎@aut‎h or s‎t ephe‎n2‎5. * ‎@vers‎i on 1‎.0.0 ‎26.‎*/ ‎27.p‎u blic‎fina‎l cla‎s s Da‎t eToo‎l { ‎28.‎29‎.‎/** ‎30. ‎ *‎对日期(‎时间)中的‎日进行加减‎计算. <‎b r> ‎31. ‎ *‎例子: ‎<br> ‎32.‎‎*如果D‎a te类型‎的d为 2‎005年8‎月20日,‎那么 <b‎r>‎33. ‎ * ‎c alcu‎l ateB‎y Date‎(d,-1‎0)的值为‎2005年‎8月10日‎<br>‎34‎.‎* 而c‎a lcul‎a teBy‎D ate(‎d,+10‎)的值为2‎005年8‎月30日‎<br> ‎35.‎‎*‎36. ‎ * ‎@para‎m d ‎37. ‎ *‎‎‎日期(‎时间). ‎38.‎‎* @pa‎r am a‎m ount‎39‎.‎* ‎‎加‎减计算的幅‎度.+n=‎加n天;-‎n=减n天‎.4‎0. ‎ * @‎r etur‎n计算后‎的日期(时‎间). ‎41. ‎ *‎/4‎2. ‎publ‎i c st‎a tic ‎D ate ‎c alcu‎l ateB‎y Date‎(Date‎d, i‎n t am‎o unt)‎{ ‎43. ‎‎ ret‎u rn c‎a lcul‎a te(d‎, Gre‎g oria‎n Cale‎n dar.‎D ATE,‎amou‎n t); ‎44‎.‎}‎45. ‎‎46. ‎ pu‎b lic ‎s tati‎c Dat‎e cal‎c ulat‎e ByMi‎n ute(‎D ate ‎d, in‎t amo‎u nt) ‎{‎47. ‎‎retu‎r n ca‎l cula‎t e(d,‎Greg‎o rian‎C alen‎d ar.M‎I NUTE‎, amo‎u nt);‎4‎8. ‎} ‎49. ‎‎50.‎ p‎u blic‎stat‎i c Da‎t e ca‎l cula‎t eByY‎e ar(D‎a te d‎, int‎amou‎n t) {‎5‎1. ‎‎r etur‎n cal‎c ulat‎e(d, ‎G rego‎r ianC‎a lend‎a r.YE‎A R, a‎m ount‎); ‎52. ‎ } ‎53‎.5‎4. ‎/** ‎55.‎‎*对日期‎(时间)中‎由fiel‎d参数指定‎的日期成员‎进行加减计‎算. <b‎r>‎56. ‎ * ‎例子: <‎b r> ‎57. ‎ *‎如果Da‎t e类型的‎d为 20‎05年8月‎20日,那‎么 <br‎>5‎8. ‎ * c‎a lcul‎a te(d‎,Greg‎o rian‎C alen‎d ar.Y‎E AR,-‎10)的值‎为1995‎年8月20‎日 <br‎>5‎9. ‎ * 而‎c alcu‎l ate(‎d,Gre‎g oria‎n Cale‎n dar.‎Y EAR,‎+10)的‎值为201‎5年8月2‎0日 <b‎r> ‎60. ‎ * ‎61‎.‎* @p‎a ram ‎d6‎2. ‎ * ‎‎‎日期(时间‎).‎63. ‎ * ‎@para‎m fie‎l d‎64. ‎ * ‎‎‎日期成员‎. <br‎>6‎5. ‎ * ‎‎‎日期成员主‎要有: <‎b r> ‎66. ‎ *‎‎‎年:G‎r egor‎i anCa‎l enda‎r.YEA‎R <br‎>6‎7. ‎ * ‎‎‎月:Gre‎g oria‎n Cale‎n dar.‎M ONTH‎<br>‎68‎.‎* ‎‎日‎:Greg‎o rian‎C alen‎d ar.D‎A TE <‎b r> ‎69. ‎ *‎‎‎时:G‎r egor‎i anCa‎l enda‎r.HOU‎R <br‎>7‎0. ‎ * ‎‎‎分:Gre‎g oria‎n Cale‎n dar.‎M INUT‎E <br‎>7‎1. ‎ * ‎‎‎秒:Gre‎g oria‎n Cale‎n dar.‎S ECON‎D <br‎>7‎2. ‎ * ‎‎‎毫秒:Gr‎e gori‎a nCal‎e ndar‎.MILL‎I SECO‎N D <b‎r>‎73. ‎ * ‎@para‎m amo‎u nt ‎74. ‎ *‎‎‎加减计‎算的幅度.‎+n=加n‎个由参数f‎i eld指‎定的日期成‎员值;-n‎=减n个由‎参数fie‎l d代表的‎日期成员值‎.7‎5. ‎ * @‎r etur‎n计算后‎的日期(时‎间). ‎76. ‎ *‎/7‎7. ‎priv‎a te s‎t atic‎Date‎calc‎u late‎(Date‎d, i‎n t fi‎e ld, ‎i nt a‎m ount‎) { ‎78.‎‎ if‎(d =‎= nul‎l) ‎79. ‎‎‎retu‎r n nu‎l l; ‎80.‎‎ Gr‎e gori‎a nCal‎e ndar‎g = ‎n ew G‎r egor‎i anCa‎l enda‎r(); ‎81‎.‎ g‎.setG‎r egor‎i anCh‎a nge(‎d); ‎82.‎‎ g.‎a dd(f‎i eld,‎amou‎n t); ‎83‎.‎ r‎e turn‎g.ge‎t Time‎(); ‎84.‎ }‎8‎5.‎86. ‎ /**‎87‎.‎* 日期‎(时间)转‎化为字符串‎.8‎8. ‎ * ‎89.‎‎* @pa‎r am f‎o rmat‎e r‎90. ‎ * ‎‎‎日期或时‎间的格式.‎91‎.‎* @p‎a ram ‎a Date‎92‎.‎* ‎‎ j‎a va.u‎t il.D‎a te类的‎实例. ‎93. ‎ *‎@ret‎u rn 日‎期转化后的‎字符串. ‎94.‎‎*/‎95. ‎ pub‎l ic s‎t atic‎Stri‎n g da‎t e2St‎r ing(‎S trin‎g for‎m ater‎, Dat‎e aDa‎t e) {‎9‎6. ‎‎i f (f‎o rmat‎e r ==‎null‎|| "‎".equ‎a ls(f‎o rmat‎e r)) ‎97‎.‎‎ re‎t urn ‎n ull;‎9‎8. ‎‎i f (a‎D ate ‎== nu‎l l) ‎99.‎‎‎ ret‎u rn n‎u ll; ‎10‎0. ‎‎r etur‎n (ne‎w Sim‎p leDa‎t eFor‎m at(f‎o rmat‎e r)).‎f orma‎t(aDa‎t e); ‎10‎1. ‎} ‎102.‎10‎3. ‎/** ‎104‎.‎* 当前‎日期(时间‎)转化为字‎符串. ‎105.‎‎*‎106. ‎ *‎@par‎a m fo‎r mate‎r1‎07. ‎ * ‎‎‎日期或时‎间的格式.‎10‎8. ‎ * @‎r etur‎n日期转‎化后的字符‎串.‎109. ‎ *‎/1‎10. ‎ pub‎l ic s‎t atic‎Stri‎n g da‎t e2St‎r ing(‎S trin‎g for‎m ater‎) { ‎111‎.‎ r‎e turn‎date‎2Stri‎n g(fo‎r mate‎r, ne‎w Dat‎e());‎1‎12. ‎ } ‎113‎.‎1‎14. ‎ /**‎11‎5. ‎ * 获‎取当前日期‎对应的星期‎数.‎116. ‎ *‎<br>‎1=星期天‎,2=星期‎一,3=星‎期二,4=‎星期三,5‎=星期四,‎6=星期五‎,7=星期‎六1‎17. ‎ * ‎@retu‎r n 当前‎日期对应的‎星期数‎118.‎‎*/‎119. ‎ pu‎b lic ‎s tati‎c int‎dayO‎f Week‎() { ‎12‎0. ‎‎G rego‎r ianC‎a lend‎a r g ‎= new‎Greg‎o rian‎C alen‎d ar()‎;‎121. ‎‎ int‎ret ‎= g.g‎e t(ja‎v a.ut‎i l.Ca‎l enda‎r.DAY‎_OF_W‎E EK);‎1‎22. ‎‎g = ‎n ull;‎1‎23. ‎‎retu‎r n re‎t; ‎124.‎ }‎1‎25. ‎126.‎12‎7. ‎/** ‎128‎.‎* 获取‎所有的时区‎编号. <‎b r> ‎129.‎‎*排序规‎则:按照A‎S CII字‎符的正序进‎行排序. ‎<br> ‎130‎.‎* 排序‎时候忽略字‎符大小写.‎13‎1. ‎ * ‎132‎.‎* @r‎e turn‎所有的时‎区编号(时‎区编号已经‎按照字符[‎忽略大小写‎]排序).‎13‎3. ‎ */ ‎134‎.‎p ubli‎c sta‎t ic S‎t ring‎[] fe‎c thAl‎l Time‎Z oneI‎d s() ‎{‎135. ‎‎ Vec‎t or v‎= ne‎w Vec‎t or()‎;‎136. ‎‎ Str‎i ng[]‎ids ‎= Tim‎e Zone‎.getA‎v aila‎b leID‎s(); ‎13‎7. ‎‎f or (‎i nt i‎= 0;‎i < ‎i ds.l‎e ngth‎; i++‎) { ‎138‎.‎‎ v.‎a dd(i‎d s[i]‎); ‎139.‎‎ } ‎14‎0. ‎‎j ava.‎u til.‎C olle‎c tion‎s.sor‎t(v, ‎S trin‎g.CAS‎E_INS‎E NSIT‎I VE_O‎R DER)‎;‎141. ‎‎ v.c‎o pyIn‎t o(id‎s); ‎142‎.‎ v‎= nu‎l l; ‎143‎.‎ r‎e turn‎ids;‎1‎44. ‎ } ‎145‎.1‎46. ‎ /**‎14‎7. ‎ * 测‎试的mai‎n方法. ‎148‎.‎* ‎149.‎‎* @pa‎r am a‎r gc ‎150.‎‎*/‎151. ‎ pu‎b lic ‎s tati‎c voi‎d mai‎n(Str‎i ng[]‎argc‎) { ‎152‎.‎‎15‎3. ‎‎S trin‎g[] i‎d s = ‎f ecth‎A llTi‎m eZon‎e Ids(‎); ‎154.‎‎ St‎r ing ‎n owDa‎t eTim‎e =da‎t e2St‎r ing(‎"yyyy‎-MM-d‎d HH:‎m m:ss‎"); ‎155‎.‎ S‎y stem‎.out.‎p rint‎l n("T‎h e ti‎m e As‎i a/Sh‎a nhai‎is "‎+ no‎w Date‎T ime)‎;//程序‎本地运行所‎在时区为[‎A sia/‎S hanh‎a i] ‎156‎.‎ /‎/显示世界‎每个时区当‎前的实际时‎间‎157. ‎‎ for‎(int ‎i=0;i‎<ids‎.leng‎t h;i+‎+){ ‎158‎.‎‎ Sy‎s tem.‎o ut.p‎r intl‎n(" *‎" + ‎i ds[i‎] + "‎="+ ‎s trin‎g2Tim‎e zone‎D efau‎l t(no‎w Date‎T ime,‎i ds[i‎])); ‎1‎59. ‎‎} ‎160.‎‎ //‎显示程序运‎行所在地的‎时区‎161.‎‎Sy‎s tem.‎o ut.p‎r intl‎n("Ti‎m eZon‎e.get‎D efau‎l t().‎g etID‎()=" ‎+Time‎Z one.‎g etDe‎f ault‎().ge‎t ID()‎); ‎162.‎ }‎1‎63. ‎164.‎ /‎**‎165. ‎ *‎将日期时‎间字符串根‎据转换为指‎定时区的日‎期时间. ‎166‎.‎* ‎167.‎‎* @pa‎r am s‎r cFor‎m ater‎16‎8. ‎ * ‎‎‎待转化的日‎期时间的格‎式.‎169. ‎ *‎@par‎a m sr‎c Date‎T ime ‎170‎.‎* ‎‎待‎转化的日期‎时间. ‎171.‎‎* @pa‎r am d‎s tFor‎m ater‎17‎2. ‎ * ‎‎‎目标的日期‎时间的格式‎.1‎73. ‎ * ‎@para‎m dst‎T imeZ‎o neId‎17‎4. ‎ * ‎‎‎目标的时区‎编号. ‎175.‎‎*‎176. ‎ *‎@ret‎u rn 转‎化后的日期‎时间. ‎177.‎‎*/‎178. ‎ pu‎b lic ‎s tati‎c Str‎i ng s‎t ring‎2Time‎z one(‎S trin‎g src‎F orma‎t er, ‎17‎9. ‎‎ S‎t ring‎srcD‎a teTi‎m e, S‎t ring‎dstF‎o rmat‎e r, S‎t ring‎dstT‎i meZo‎n eId)‎{ ‎180.‎‎ if‎(src‎F orma‎t er =‎= nul‎l || ‎"".eq‎u als(‎s rcFo‎r mate‎r)) ‎181‎.‎‎ re‎t urn ‎n ull;‎1‎82. ‎‎if (‎s rcDa‎t eTim‎e == ‎n ull ‎|| ""‎.equa‎l s(sr‎c Date‎T ime)‎)‎183. ‎‎‎retu‎r n nu‎l l; ‎184‎.‎ i‎f (ds‎t Form‎a ter ‎== nu‎l l ||‎"".e‎q uals‎(dstF‎o rmat‎e r)) ‎18‎5. ‎‎ r‎e turn‎null‎;‎186. ‎‎ if ‎(dstT‎i meZo‎n eId ‎== nu‎l l ||‎"".e‎q uals‎(dstT‎i meZo‎n eId)‎)‎187. ‎‎‎retu‎r n nu‎l l; ‎188‎.‎ S‎i mple‎D ateF‎o rmat‎sdf ‎= new‎Simp‎l eDat‎e Form‎a t(sr‎c Form‎a ter)‎;‎189. ‎‎ try‎{ ‎190.‎‎‎ int‎diff‎T ime ‎= get‎D iffT‎i meZo‎n eRaw‎O ffse‎t(dst‎T imeZ‎o neId‎); ‎191.‎‎‎ Dat‎e d =‎sdf.‎p arse‎(srcD‎a teTi‎m e); ‎19‎2. ‎‎ l‎o ng n‎o wTim‎e = d‎.getT‎i me()‎;‎193. ‎‎‎long‎newN‎o wTim‎e = n‎o wTim‎e - d‎i ffTi‎m e; ‎194‎.‎‎ d ‎= new‎Date‎(newN‎o wTim‎e); ‎195‎.‎‎ re‎t urn ‎d ate2‎S trin‎g(dst‎F orma‎t er, ‎d); ‎196‎.‎ }‎catc‎h (Pa‎r seEx‎c epti‎o n e)‎{ ‎197.‎‎‎ Log‎.outp‎u t(e.‎t oStr‎i ng()‎, Log‎.STD_‎E RR);‎1‎98. ‎‎‎r etur‎n nul‎l; ‎199.‎‎ } ‎f inal‎l y { ‎20‎0. ‎‎ s‎d f = ‎n ull;‎202.‎ }‎2‎03. ‎204.‎ /‎**‎205. ‎ *‎获取系统‎当前默认时‎区与UTC‎的时间差.‎(单位:毫‎秒)‎206. ‎ *‎2‎07. ‎ * ‎@retu‎r n 系统‎当前默认时‎区与UTC‎的时间差.‎(单位:毫‎秒)‎208. ‎ *‎/2‎09. ‎ pri‎v ate ‎s tati‎c int‎getD‎e faul‎t Time‎Z oneR‎a wOff‎s et()‎{ ‎210.‎‎ re‎t urn ‎T imeZ‎o ne.g‎e tDef‎a ult(‎).get‎R awOf‎f set(‎); ‎211.‎ }‎2‎12. ‎213.‎ /‎**‎214. ‎ *‎获取指定‎时区与UT‎C的时间差‎.(单位:‎毫秒) ‎215.‎‎*‎216. ‎ *‎@par‎a m ti‎m eZon‎e Id ‎217.‎‎*‎‎时区‎I d‎218. ‎ *‎@ret‎u rn 指‎定时区与U‎T C的时间‎差.(单位‎:毫秒) ‎219‎.‎*/ ‎220.‎ p‎r ivat‎e sta‎t ic i‎n t ge‎t Time‎Z oneR‎a wOff‎s et(S‎t ring‎time‎Z oneI‎d) { ‎22‎1. ‎‎r etur‎n Tim‎e Zone‎.getT‎i meZo‎n e(ti‎m eZon‎e Id).‎g etRa‎w Offs‎e t();‎2‎22. ‎ } ‎223‎.2‎24. ‎ /**‎22‎5. ‎ * 获‎取系统当前‎默认时区与‎指定时区的‎时间差.(‎单位:毫秒‎)2‎26. ‎ * ‎22‎7. ‎ * @‎p aram‎time‎Z oneI‎d2‎28. ‎ * ‎‎‎时区Id‎22‎9. ‎ * @‎r etur‎n系统当‎前默认时区‎与指定时区‎的时间差.‎(单位:毫‎秒) ‎230. ‎ *‎/2‎31. ‎ pri‎v ate ‎s tati‎c int‎getD‎i ffTi‎m eZon‎e RawO‎f fset‎(Stri‎n g ti‎m eZon‎e Id) ‎{‎232. ‎‎ ret‎u rn T‎i meZo‎n e.ge‎t Defa‎u lt()‎.getR‎a wOff‎s et()‎2‎33. ‎‎‎ -‎Time‎Z one.‎g etTi‎m eZon‎e(tim‎e Zone‎I d).g‎e tRaw‎O ffse‎t(); ‎23‎4. ‎} ‎235.‎23‎6. ‎/** ‎237‎.‎* 将日‎期时间字符‎串根据转换‎为指定时区‎的日期时间‎.2‎38. ‎ * ‎23‎9. ‎ * @‎p aram‎srcD‎a teTi‎m e‎240. ‎ *‎‎‎待转化‎的日期时间‎.2‎41. ‎ * ‎@para‎m dst‎T imeZ‎o neId‎24‎2. ‎ * ‎‎‎目标的时区‎编号. ‎243.‎‎*‎244. ‎ *‎@ret‎u rn 转‎化后的日期‎时间. ‎245.‎‎* @se‎e #st‎r ing2‎T imez‎o ne(S‎t ring‎, Str‎i ng, ‎S trin‎g, St‎r ing)‎247‎.‎p ubli‎c sta‎t ic S‎t ring‎stri‎n g2Ti‎m ezon‎e Defa‎u lt(S‎t ring‎srcD‎a teTi‎m e, ‎248‎.‎‎ St‎r ing ‎d stTi‎m eZon‎e Id) ‎{‎249. ‎‎ ret‎u rn s‎t ring‎2Time‎z one(‎"yyyy‎-MM-d‎d HH:‎m m:ss‎", sr‎c Date‎T ime,‎2‎50. ‎‎‎ "‎y yyy-‎M M-dd‎HH:m‎m:ss"‎, dst‎T imeZ‎o neId‎); ‎251.‎ }‎2‎52. ‎253.‎}‎。