Java的时间处理
java日期处理输入输出(度微尔开发者联盟编辑整理)
// 年的加减
public static final int SUB_YEAR = Calendar.YEAR;
// 月加减
public static final int SUB_MONTH = Calendar.MONTH;
// 天的加减
public static int getToday() {
Calendar calendar = Calendar.getInstance();
return calendar.get(Calendar.DATE);
}
return d;
}
/**
* 把日期转换为字符串
*/
public static String dateToString(java.util.Date date, String format) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.add(dateKind, amount);
return dateToString(calendar.getTime(), FORMAT_ONE);
calendar.set(year, month - 1, 1);
return calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
}
/**
* 获得当前日期
*/
import java.util.GregorianCalendar;
import java.util.regex.Pattern;
import mons.logging.Log;
Java时间日期处理技巧:日期格式化和时区设置
Java时间日期处理技巧:日期格式化和时区设置在Java编程中,日期和时间处理是非常常见的任务。
无论是在开发Web应用程序、处理数据还是进行系统日志记录,都需要对日期和时间进行操作。
本文将介绍一些Java中常用的日期格式化和时区设置的技巧,帮助开发者更好地处理日期和时间。
1. 日期格式化日期格式化是将日期对象转换为特定格式的字符串表示。
Java提供了SimpleDateFormat类来实现日期格式化。
以下是一个简单的例子:```javaimport java.text.SimpleDateFormat;import java.util.Date;public class DateFormatExample {public static void main(String[] args) {Date date = new Date();SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");String formattedDate = sdf.format(date);System.out.println("Formatted Date: " + formattedDate);}}```在上面的例子中,我们使用了"yyyy-MM-dd HH:mm:ss"作为日期格式化的模式,它将日期格式化为"年-月-日时:分:秒"的形式。
Java的日期格式化模式有很多选项,可以根据需求进行调整。
例如,"yyyy-MM-dd"表示"年-月-日","HH:mm:ss"表示"时:分:秒","EEE"表示星期几等等。
更多的格式化选项可以参考Java官方文档。
2. 时区设置时区是指地球上划分的不同区域,每个时区都有自己的标准时间。
关于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处理时间获取⼏分钟前、⼏⼩时前import java.util.Date;public class RelativeDateHandler {private static final long ONE_MINUTE = 60000L;private static final long ONE_HOUR = 3600000L;private static final long ONE_DAY = 86400000L;private static final long ONE_WEEK = 604800000L;private static final String ONE_SECOND_AGO = "秒前";private static final String ONE_MINUTE_AGO = "分钟前";private static final String ONE_HOUR_AGO = "⼩时前";private static final String ONE_DAY_AGO = "天前";private static final String ONE_MONTH_AGO = "⽉前";private static final String ONE_YEAR_AGO = "年前";public static String format(Date date) {long delta = new Date().getTime() - date.getTime();if (delta < 1L * ONE_MINUTE) {long seconds = toSeconds(delta);return (seconds <= 0 ? 1 : seconds) + ONE_SECOND_AGO;}if (delta < 45L * ONE_MINUTE) {long minutes = toMinutes(delta);return (minutes <= 0 ? 1 : minutes) + ONE_MINUTE_AGO;}if (delta < 24L * ONE_HOUR) {long hours = toHours(delta);return (hours <= 0 ? 1 : hours) + ONE_HOUR_AGO;}if (delta < 48L * ONE_HOUR) {return "昨天";}if (delta < 30L * ONE_DAY) {long days = toDays(delta);return (days <= 0 ? 1 : days) + ONE_DAY_AGO;}if (delta < 12L * 4L * ONE_WEEK) {long months = toMonths(delta);return (months <= 0 ? 1 : months) + ONE_MONTH_AGO;} else {long years = toYears(delta);return (years <= 0 ? 1 : years) + ONE_YEAR_AGO;}}private static long toSeconds(long date) {return date / 1000L;}private static long toMinutes(long date) {return toSeconds(date) / 60L;}private static long toHours(long date) {return toMinutes(date) / 60L;}private static long toDays(long date) {return toHours(date) / 24L;}private static long toMonths(long date) {return toDays(date) / 30L;}private static long toYears(long date) {return toMonths(date) / 365L;}}。
JAVA处理日期时间常用方法
JA V A处理日期时间常用方法:java.util.CalendarCalendar 类是一个抽象类,它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法,并为操作日历字段(例如获得下星期的日期提供了一些方法。
瞬间可用毫秒值来表示,它是距历元(即格林威治标准时间1970 年 1 月1 日的00:00:00。
000,格里高利历的偏移量.例:Calendar cal = Calendar。
getInstance(;//使用默认时区和语言环境获得一个日历。
cal。
add(Calendar.DAY_OF_MONTH, -1;//取当前日期的前一天。
cal。
add(Calendar。
DAY_OF_MONTH, +1;//取当前日期的后一天。
//通过格式化输出日期java.text.SimpleDateFormat format = new java.text。
SimpleDateFormat(”yyyy-MM—dd";System。
out.println("Today is:”+format。
format(Calendar.getInstance(.getTime (;System。
out.println("yesterday is:"+format.format(cal.getTime(;得到2007—12-25日期: Calendar calendar = new GregorianCalendar(2007,11, 25,0,0,0;Date date = calendar.getTime(;System。
out.println("2007 Christmasis:”+format.format(date;//java月份是从0—11,月份设置时要减1。
//GregorianCalendar构造方法参数依次为:年,月—1,日,时,分,秒。
JAVA格式化日期、时间的方法
JAVA格式化⽇期、时间的⽅法使⽤ DateFormat 格式化⽇期、时间DateFormat 也是⼀个抽象类,它也提供了如下⼏个类⽅法⽤于获取 DateFormat 对象。
getDateInstance():返回⼀个⽇期格式器,它格式化后的字符串只有⽇期,没有时间。
该⽅法可以传⼊多个参数,⽤于指定⽇期样式和 Locale 等参数;如果不指定这些参数,则使⽤默认参数。
getTimeInstance():返回⼀个时间格式器,它格式化后的字符串只有时间,没有⽇期。
该⽅法可以传⼊多个参数,⽤于指定时间样式和 Locale 等参数;如果不指定这些参数,则使⽤默认参数。
getDateTimeInstance():返回⼀个⽇期、时间格式器,它格式化后的字符串既有⽇期,也有时间。
该⽅法可以传⼊多个参数,⽤于指定⽇期样式、时间样式和 Locale 等参数;如果不指定这些参数,则使⽤默认参数。
上⾯三个⽅法可以指定⽇期样式、时间样式参数,它们是的4个静态常量:FULL、LONG、MEDIUM 和 SHORT,通过这4个样式参数可以控制⽣成的格式化字符串。
看如下例⼦程序。
import java.util.*;import java.text.*;import static java.text.DateFormat.*;public class DateFormatTest {public static void main(String[] args) throws ParseException {// 需要被格式化的时间Date dt = new Date();// 创建两个Locale,分别代表中国、美国Locale[] locales = { Locale.CHINA, };DateFormat[] df = new DateFormat[16];// 为上⾯两个Locale创建16个DateFormat对象for (int i = 0; i < locales.length; i++) {df[i * 8] = DateFormat.getDateInstance(SHORT, locales[i]);df[i * 8 + 1] = DateFormat.getDateInstance(MEDIUM, locales[i]);df[i * 8 + 2] = DateFormat.getDateInstance(LONG, locales[i]);df[i * 8 + 3] = DateFormat.getDateInstance(FULL, locales[i]);df[i * 8 + 4] = DateFormat.getTimeInstance(SHORT, locales[i]);df[i * 8 + 5] = DateFormat.getTimeInstance(MEDIUM, locales[i]);df[i * 8 + 6] = DateFormat.getTimeInstance(LONG, locales[i]);df[i * 8 + 7] = DateFormat.getTimeInstance(FULL, locales[i]);}for (int i = 0; i < locales.length; i++) {String tip = i == 0 ? "----中国⽇期格式----" : "----美国⽇期格式----";System.out.println(tip);System.out.println("SHORT格式的⽇期格式:" + df[i * 8].format(dt));System.out.println("MEDIUM格式的⽇期格式:" + df[i * 8 + 1].format(dt));System.out.println("LONG格式的⽇期格式:" + df[i * 8 + 2].format(dt));System.out.println("FULL格式的⽇期格式:" + df[i * 8 + 3].format(dt));System.out.println("SHORT格式的时间格式:" + df[i * 8 + 4].format(dt));System.out.println("MEDIUM格式的时间格式:" + df[i * 8 + 5].format(dt));System.out.println("LONG格式的时间格式:" + df[i * 8 + 6].format(dt));System.out.println("FULL格式的时间格式:" + df[i * 8 + 7].format(dt));}}}上⾯程序共创建了16个 DateFormat 对象,分别为中国、美国两个 Locale 各创建8个 DateFormat 对象,分别是 SHORT、MEDIUM、LONG、FULL 四种样式的⽇期格式器、时间格式器。
java中timestamp 时间戳转换时间的方法
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 对象。
JAVA中的时间操作 new Date()
经常看见jsp版里有人问时间操作的问题,这些问题一般包括:取当前时间,把一个指定的字符串时间转化成时间类型,求两个时间之间的天数,求一段时间以前的时间,求一段时间以后的时间,在这里就把这些问题汇总一下。
<%@ page contentType="text/html;charset=gb2312"%><%@ page import="java.text.*"%><%@ page import="java.util.*"%><%//字符串转化成时间类型(字符串可以是任意类型,只要和SimpleDateFormat中的格式一致即可)java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("M/dd/yyyy hh:mm:ss a",);java.util.Date d = sdf.parse("5/13/2003 10:31:37 AM");out.println(d);out.println("<br>");SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");String mDateTime1=formatter.format(d);out.println(mDateTime1);out.println("<br>");out.println(d.getTime());out.println("<br>");//当前时间Calendar cal = Calendar.getInstance();// SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss G E D F w W a E F");String mDateTime=formatter.format(cal.getTime());out.println(mDateTime);out.println("<br>");//1年前日期java.util.Date myDate=new java.util.Date();long myTime=(myDate.getTime()/1000)-60*60*24*365;myDate.setTime(myTime*1000);String mDate=formatter.format(myDate);out.println(mDate);out.println("<br>");//明天日期myDate=new java.util.Date();myTime=(myDate.getTime()/1000)+60*60*24;myDate.setTime(myTime*1000);mDate=formatter.format(myDate);out.println(mDate);out.println("<br>");//两个时间之间的天数SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd"); java.util.Date date= myFormatter.parse("2003-05-1");java.util.Date mydate= myFormatter.parse("1899-12-30");long day=(date.getTime()-mydate.getTime())/(24*60*60*1000);out.println(day);out.println("<br>");//加半小时SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"); java.util.Date date1 = format.parse("2002-02-28 23:16:00");long Time=(date1.getTime()/1000)+60*30;date1.setTime(Time*1000);String mydate1=formatter.format(date1);out.println(mydate1);out.println("<br>");//年月周求日期SimpleDateFormat formatter2 = new SimpleDateFormat("yyyy-MM F E"); java.util.Date date2= formatter2.parse("2003-05 5 星期五"); SimpleDateFormat formatter3 = new SimpleDateFormat("yyyy-MM-dd"); String mydate2=formatter3.format(date2);out.println(mydate2);out.println("<br>");//求是星期几mydate= myFormatter.parse("2001-1-1");SimpleDateFormat formatter4 = new SimpleDateFormat("E"); String mydate3=formatter4.format(mydate);out.println(mydate3);out.println("<br>");%>。
java date的add()方法
java date的add()方法Java中的Date类是一个用于表示日期和时间的类。
在处理时间数据时,经常需要进行日期计算、加减等操作,而这时就可以用到Date类的add()方法。
本文将介绍Java Date类中的add()方法,包括使用方法、参数意义和一些应用场景。
一、使用方法Date类中的add()方法用于对日期对象进行加减操作。
它的完整签名如下:public void add(int field, int amount)其中,参数field表示要进行加减的时间域,如小时、分钟、天等;参数amount表示要加减的数量,正数表示加,负数表示减。
二、参数意义1.时间域常用的时间域有以下几种:• Calendar.YEAR:年• Calendar.MONTH:月• Calendar.DAY_OF_MONTH:日• Calendar.HOUR_OF_DAY:时• Calendar.MINUTE:分• Calendar.SECOND:秒2.加减数量加减数量通常是一个整数,可正可负,表示要加减的个数。
三、应用场景1.日期计算用add()方法可以方便地对日期进行加减,从而进行一些计算。
如下面代码示例:Date date = new Date();Calendar cal = Calendar.getInstance();cal.setTime(date);cal.add(Calendar.DAY_OF_MONTH, 1);Date newDate = cal.getTime();上述代码中,我们创建了一个当前时间的Date对象,然后将其转化为Calendar类型。
接着,我们通过add()方法来增加一天的时间,并将修改后的日期重新转化为Date类型,从而得到了增加一天后的日期。
2.时间比较有时候需要判断两个日期之间的差距,就需要用到add()方法来进行时间的减法。
比如,我们要求两个日期之间的天数差,可以如下操作:Date date1 = new Date();Date date2 = new Date(date1.getTime() + 24 * 3600 * 1000);long difference = (date2.getTime() - date1.getTime()) / (1000 * 3600 * 24);在上面的代码中,我们用add()方法来实现了时间的减法,从而得出了date2比date1多1天的日期,再进行减法就可以得出两个日期之间的天数差。
java之时间戳处理
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写到这⾥,相信⼤家都明⽩了为啥同⼀个程序在不同机器上跑出的涉及时间戳的结果不⼀致,这⼀点要注意额,千万别掉坑⾥。
java 国际标准时间字符串转换
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 date before和after的用法-概述说明以及解释
java date before和after的用法-概述说明以及解释1.引言1.1 概述在Java编程中,日期和时间的处理是一项重要的任务。
在处理日期和时间时,常常需要进行比较或者判断时间先后顺序的操作。
Java提供了Date类作为表示日期和时间的类,并且通过before和after方法提供了便捷的日期比较功能。
在本篇文章中,我们将深入探讨Java Date类的before和after方法的用法。
这两个方法可以用来比较两个日期的先后关系,并且返回相应的布尔值。
在接下来的正文部分,我们将首先介绍Java中的Date类,了解它的基本功能和使用方法。
然后,我们将详细讨论Date类的before方法和after方法,探讨它们的使用场景和注意事项。
最后,我们将对所学内容进行总结,并提供一些实际应用场景的示例,以帮助读者更好地理解和运用before和after方法。
通过学习本文,读者将能够全面掌握Java中Date类的before和after 方法的用法,从而在实际开发中更加灵活和高效地处理日期和时间的比较操作。
让我们开始探索吧!1.2文章结构《Java Date before和after的用法》文章结构:1. 引言1.1 概述1.2 文章结构文章将分为以下几个部分:- 正文部分将介绍Java中的Date类以及其常用的before和after方法的用法。
- 结论部分将对这两个方法的使用进行总结,并探讨它们在实际应用中的使用场景。
2. 正文2.1 Java中的Date类- 简要介绍Java中的Date类,提及其在日期和时间处理中的常用性。
2.2 Date类的before方法- 解释before方法的作用,即判断一个日期是否在另一个日期之前。
- 详细介绍before方法的使用方式,包括参数的含义和返回值的含义。
- 给出一些示例代码以帮助读者更好地理解before方法的实际应用。
2.3 Date类的after方法- 解释after方法的作用,即判断一个日期是否在另一个日期之后。
java处理日期时间相加减大全
java处理⽇期时间相加减⼤全 本⽂由⼴州疯狂软件java培训分享: java处理⽇期时间相加减 JAVA处理⽇期时间常⽤⽅法: 1.java.util.Calendar Calendar 类是⼀个抽象类,它为特定瞬间与⼀组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等⽇历字段之间的转换提供了⼀些⽅法,并为操作⽇历字段(例如获得下星期的⽇期)提供了⼀些⽅法。
瞬间可⽤毫秒值来表⽰,它是距历元(即格林威治标准时间 1970 年 1⽉ 1 ⽇的 00:00:00.000,格⾥⾼利历)的偏移量。
例: Java代码 1. Calendar cal = Calendar.getInstance();//使⽤默认时区和语⾔环境获得⼀个⽇历。
2. cal.add(Calendar.DAY_OF_MONTH, -1);//取当前⽇期的前⼀天. 3. 4. cal.add(Calendar.DAY_OF_MONTH, +1);//取当前⽇期的后⼀天. 5. 6. //通过格式化输出⽇期 7. java.text.SimpleDateFormat format = new java.text.SimpleDateFormat("yyyy-MM-dd"); 8. 9. System.out.println("Today is:"+format.format(Calendar.getInstance().getTime())); 10. 11. System.out.println("yesterday is:"+format.format(cal.getTime())); 得到2007-12-25⽇期: Java代码 1. Calendar calendar = new GregorianCalendar(2007, 11, 25,0,0,0); 2. Date date = calendar.getTime(); 3. System.out.println("2007 Christmas is:"+format.format(date)); java⽉份是从0-11,⽉份设置时要减1. GregorianCalendar构造⽅法参数依次为:年,⽉-1,⽇,时,分,秒.取⽇期的部分: Java代码 1. int year =calendar.get(Calendar.YEAR); 2. 3. int month=calendar.get(Calendar.MONTH)+1; 4. 5. int day =calendar.get(Calendar.DAY_OF_MONTH); 6. 7. int hour =calendar.get(Calendar.HOUR_OF_DAY); 8. 9. int minute =calendar.get(Calendar.MINUTE); 10. 11. int seconds =calendar.get(Calendar.SECOND); 取⽉份要加1. 判断当前⽉份的最⼤天数: Java代码 1. Calendar cal = Calendar.getInstance(); 2. int day=cal.getActualMaximum(Calendar.DAY_OF_MONTH); 3. System.out.println(day); 2.java.util.Date Java代码 1. java.util.Date today=new java.util.Date(); 2. System.out.println("Today is "+formats.format(today)); 取当⽉的第⼀天: Java代码 1. java.text.SimpleDateFormat format = new java.text.SimpleDateFormat("yyyy-MM-01"); 2. java.util.Date firstDay=new java.util.Date(); 3. System.out.println("the month first day is "+formats.format(firstDay)); 取当⽉的最后⼀天: Java代码 1. 2. Calendar cal = Calendar.getInstance(); 3. int maxDay=cals.getActualMaximum(Calendar.DAY_OF_MONTH); 4. java.text.Format formatter3=new java.text.SimpleDateFormat("yyyy-MM-"+maxDay); 5. System.out.println(formatter3.format(cal.getTime())); 求两个⽇期之间相隔的天数: Java代码 1. java.text.SimpleDateFormat format = new java.text.SimpleDateFormat("yyyy-MM-dd"); 2. java.util.Date beginDate= format.parse("2007-12-24"); 3. java.util.Date endDate= format.parse("2007-12-25"); 4. long day=(date.getTime()-mydate.getTime())/(24*60*60*1000); 5. System.out.println("相隔的天数="+day); ⼀年前的⽇期: Java代码 1. java.text.Format formatter=new java.text.SimpleDateFormat("yyyy-MM-dd"); 2. java.util.Date todayDate=new java.util.Date(); 3. long beforeTime=(todayDate.getTime()/1000)-60*60*24*365; 4. todayDate.setTime(beforeTime*1000); 5. String beforeDate=formatter.format(todayDate); 6. System.out.println(beforeDate); ⼀年后的⽇期: Java代码 1. java.text.Format formatter=new java.text.SimpleDateFormat("yyyy-MM-dd"); 2. java.util.Date todayDate=new java.util.Date(); 3. long afterTime=(todayDate.getTime()/1000)+60*60*24*365; 4. todayDate.setTime(afterTime*1000); 5. String afterDate=formatter.format(todayDate); 6. System.out.println(afterDate); 求10⼩时后的时间 Java代码 1. java.util.Calendar Cal=java.util.Calendar.getInstance(); 2. Cal.setTime(dateOper); 3. Cal.add(java.util.Calendar.HOUR_OF_DAY,10); 4. System.out.println("date:"+forma.format(Cal.getTime())); 求10⼩时前的时间 Java代码 1. java.util.Calendar Cal=java.util.Calendar.getInstance(); 2. Cal.setTime(dateOper); 3. Cal.add(java.util.Calendar.HOUR_OF_DAY,-10); 4. System.out.println("date:"+forma.format(Cal.getTime())); 3.java.sql.Date 继承⾃java.util.Date,是操作数据库⽤的⽇期类型 Java代码 1. java.sql.Date sqlDate = new java.sql.Date(java.sql.Date.valueOf("2007-12-25").getTime()); ⽇期⽐较:简单的⽐较可以以字符串的形式直接⽐较,也可使⽤ java.sql.Date.valueOf("2007-03-08").compareTo(java.sql.Date.valueOf("2007-03-18"))⽅式来⽐较⽇期的⼤⼩.也可使⽤java.util.Date.after(java.util.Date)来⽐较. 相差时间: long difference=c2.getTimeInMillis()-c1.getTimeInMillis(); 相差天数:long day=difference/(3600*24*1000) 相差⼩时:long hour=difference/(3600*1000) 相差分钟:long minute=difference/(60*1000) 相差秒: long second=difference/1000 疯狂软件教育中⼼依托开发团队的强⼤技术实⼒,把企业最新技术融⼊实训课程,打造⾦牌的品质,才能给予学员黄⾦的未来,疯狂软件凭借过硬的技术实⼒与丰富的项⽬开发经验,赢得了社会的肯定。
timestamp数据类型用法java
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类。
java雪花算法时间回拨处理
java雪花算法时间回拨处理Java雪花算法时间回拨处理随着互联网的发展,分布式系统的应用越来越广泛。
在分布式系统中,唯一ID的生成是非常重要的一个环节。
传统的自增ID生成方式在分布式系统中很难保证唯一性,因此需要一种更好的解决方案。
雪花算法(Snowflake)就是一种可以在分布式系统中生成唯一ID 的算法。
然而,雪花算法在处理时间回拨的情况下需要特殊处理。
时间回拨是指系统时间突然向前调整,这可能会导致雪花算法生成的ID出现重复。
为了解决这个问题,我们需要在算法中增加一些逻辑来处理时间回拨。
我们需要了解雪花算法的基本原理。
雪花算法生成的ID是一个64位的整数,其中包含了以下几个部分:1. 第一个部分是一个41位的时间戳,记录了ID的生成时间,精确到毫秒级。
2. 第二个部分是一个10位的机器ID,用来标识不同的机器。
3. 第三个部分是一个12位的序列号,用来标识同一毫秒内生成的不同ID。
在正常情况下,雪花算法生成的ID是递增的,通过对时间戳、机器ID和序列号的组合来保证唯一性。
但是当系统时间发生回拨时,就有可能导致生成的ID重复。
要处理时间回拨,我们需要在雪花算法中增加一些逻辑。
首先,我们需要记录上一次生成ID的时间戳lastTimestamp。
当生成新的ID 时,我们需要比较当前时间戳和lastTimestamp的大小关系。
如果当前时间戳小于lastTimestamp,说明发生了时间回拨。
这种情况下,我们需要等待直到时间追赶上lastTimestamp,然后再生成新的ID。
为了等待时间的过程中不浪费资源,我们可以使用Thread.sleep()方法来暂停程序执行。
我们还需要对序列号进行特殊处理。
在时间回拨的情况下,序列号需要重新开始计数,以保证生成的ID仍然是唯一的。
因此,当时间回拨发生时,我们需要将序列号重置为0,并且在生成新的ID时,从0开始递增。
处理时间回拨的代码示例如下:```javapublic class SnowflakeIdGenerator {// 机器IDprivate long machineId;// 序列号private long sequence = 0L;// 上一次生成ID的时间戳private long lastTimestamp = -1L;public SnowflakeIdGenerator(long machineId) {this.machineId = machineId;}public synchronized long generateId() {long timestamp = System.currentTimeMillis();if (timestamp < lastTimestamp) {// 时间回拨,等待时间追赶上lastTimestamptry {Thread.sleep(lastTimestamp - timestamp); } catch (InterruptedException e) {e.printStackTrace();}timestamp = System.currentTimeMillis();}if (timestamp == lastTimestamp) {// 同一毫秒内生成多个ID,需要通过序列号区分 sequence = (sequence + 1) & 4095;if (sequence == 0) {// 序列号超过最大值,等待下一毫秒再生成timestamp = tilNextMillis(lastTimestamp);}} else {// 不同毫秒内生成的ID,序列号重置为0sequence = 0L;}lastTimestamp = timestamp;return ((timestamp - 1546300800000L) << 22) | (machineId << 12) | sequence;}private long tilNextMillis(long lastTimestamp) {long timestamp = System.currentTimeMillis();while (timestamp <= lastTimestamp) {timestamp = System.currentTimeMillis();}return timestamp;}}```在上述代码中,generateId()方法用于生成ID。
java对世界各个时区(TimeZone)的通用转换处理方法
java对世界各个时区(Time Zone)的通用转换处理方法.在进行国际性软件项目开发的过程中,有时候会碰到一些比较特殊的要求。
比如:比如说,你做的是个购物网站(假设服务器放在中国上海),当全世界客户在你的网站上下订单买东西后,往往希望看到客户所在地下单时间,比如说我是个美国纽约人,我在你的网站上下单后,你给我看到一个上海的下单时间,会觉得非常的奇怪。
众所周知,纽约时间相对上海时间大约要晚13小时,如果让客户看到本地时区的时间,将变得更加符合客户的时间观念,使得客户理解比较方便。
其实,java中早已考虑过世界时区(Time Zone)这个问题,并给出了比较合理的解决方法,可以比较方便的进行世界时区时间的转化,将一个时区的时间转换成另一个时区的时间。
可以看看下面的的实际例子(运行例子的main()方法)。
关于如何知道客户所在的时区,可以根据客户所在的ip或者用户注册提供的国家来计算出所在的时区。
Java代码 01./* 02.* Cre atedon 2005-6-10 03. * Auth or st ephen04. * E mailzhouj ianqi ang A T gma il DO T com05. * C opyRi ght(C)2005-2008 , Al l rig hts r eserv ed. 06.*/ 07.pa ckage com.soft4j.uti lity;08. 09.im portjava.text.Parse Excep tion;10.imp ort j ava.t ext.S imple DateF ormat; 11.im portjava.util.Date;12.imp ort j ava.u til.G regor ianCa lenda r; 13.i mport java.util.Time Zone;14.imp ort j ava.u til.V ector; 15. 16.i mport com.soft4j.log.Log;17. 18./**19. *与日期、时间相关的一些常用工具方法. 20.* <p>21. * 日期(时间)的常用格式(form ater)主要有:<br>22. * yy yy-MM-dd H H:mm:ss <b r> 23. *24. *@auth or st ephen25. * @versi on 1.0.0 26.*/ 27.pu blicfinal clas s Dat eTool { 28.29./** 30. *对日期(时间)中的日进行加减计算. <b r> 31. *例子: <br> 32.*如果Da te类型的d为 2005年8月20日,那么 <br>33. * c alcul ateBy Date(d,-10)的值为2005年8月10日<br>34.* 而ca lcula teByD ate(d,+10)的值为2005年8月30日<br> 35.*36. * @param d 37. *日期(时间). 38.* @par am am ount39.* 加减计算的幅度.+n=加n天;-n=减n天.40. * @r eturn计算后的日期(时间). 41. */42. publi c sta tic D ate c alcul ateBy Date(Dated, in t amo unt){ 43. retu rn ca lcula te(d, Greg orian Calen dar.D ATE,amoun t); 44.}45. 46. pub lic s tatic Date calc ulate ByMin ute(D ate d, int amou nt) {47. retur n cal culat e(d,Grego rianC alend ar.MI NUTE, amou nt);48. } 49. 50. pu blicstati c Dat e cal culat eByYe ar(Da te d, intamoun t) {51. r eturn calc ulate(d, G regor ianCa lenda r.YEA R, am ount); 52. } 53.54. /** 55.*对日期(时间)中由field参数指定的日期成员进行加减计算. <br>56. * 例子: <b r> 57. *如果Dat e类型的d为 2005年8月20日,那么 <br>58. * ca lcula te(d,Grego rianC alend ar.YE AR,-10)的值为1995年8月20日 <br>59. * 而c alcul ate(d,Greg orian Calen dar.Y EAR,+10)的值为2015年8月20日 <br> 60. * 61.* @pa ram d62. * 日期(时间).63. * @param fiel d64. * 日期成员. <br>65. * 日期成员主要有: <b r> 66. *年:Gr egori anCal endar.YEAR <br>67. * 月:Greg orian Calen dar.M ONTH<br>68.* 日:Grego rianC alend ar.DA TE <b r> 69. *时:Gr egori anCal endar.HOUR <br>70. * 分:Greg orian Calen dar.M INUTE <br>71. * 秒:Greg orian Calen dar.S ECOND <br>72. * 毫秒:Gre goria nCale ndar.MILLI SECON D <br>73. * @param amou nt 74. *加减计算的幅度.+n=加n个由参数fi eld指定的日期成员值;-n=减n个由参数fiel d代表的日期成员值.75. * @r eturn计算后的日期(时间). 76. */77. priva te st aticDatecalcu late(Dated, in t fie ld, i nt am ount) { 78. if(d == null) 79. retur n nul l; 80. Gre goria nCale ndarg = n ew Gr egori anCal endar(); 81. g.setGr egori anCha nge(d); 82. g.a dd(fi eld,amoun t); 83. re turng.get Time(); 84. }85.86. /**87.* 日期(时间)转化为字符串.88. * 89.* @par am fo rmate r90. * 日期或时间的格式.91.* @pa ram a Date92.* ja va.ut il.Da te类的实例. 93. *@retu rn 日期转化后的字符串. 94.*/95. publ ic st aticStrin g dat e2Str ing(S tring form ater, Date aDat e) {96. i f (fo rmate r ==null|| "".equa ls(fo rmate r)) 97. ret urn n ull;98. i f (aD ate == nul l) 99. retu rn nu ll; 100. r eturn (new Simp leDat eForm at(fo rmate r)).f ormat(aDat e); 101. } 102.103. /** 104.* 当前日期(时间)转化为字符串. 105.*106. *@para m for mater107. * 日期或时间的格式.108. * @r eturn日期转化后的字符串.109. */110. publ ic st aticStrin g dat e2Str ing(S tring form ater) { 111. re turndate2Strin g(for mater, new Date());112. } 113.114. /**115. * 获取当前日期对应的星期数.116. *<br>1=星期天,2=星期一,3=星期二,4=星期三,5=星期四,6=星期五,7=星期六117. * @retur n 当前日期对应的星期数118.*/119. pub lic s tatic intdayOf Week() { 120. G regor ianCa lenda r g = newGrego rianC alend ar();121. intret = g.ge t(jav a.uti l.Cal endar.DAY_OF_WE EK);122. g = n ull;123. retur n ret; 124. }125. 126.127. /** 128.* 获取所有的时区编号. <b r> 129.*排序规则:按照AS CII字符的正序进行排序. <br> 130.* 排序时候忽略字符大小写.131. * 132.* @re turn所有的时区编号(时区编号已经按照字符[忽略大小写]排序).133. */ 134.p ublic stat ic St ring[] fec thAll TimeZ oneId s() {135. Vect or v= new Vect or();136. Stri ng[]ids = Time Zone.getAv ailab leIDs(); 137. f or (i nt i= 0;i < i ds.le ngth; i++) { 138. v.a dd(id s[i]); 139. } 140. j ava.u til.C ollec tions.sort(v, S tring.CASE_INSE NSITI VE_OR DER);141. v.co pyInt o(ids); 142. v= nul l; 143. re turnids;144. } 145.146. /**147. * 测试的main方法. 148.* 149.* @par am ar gc 150.*/151. pub lic s tatic void main(Stri ng[]argc) { 152.153. S tring[] id s = f ecthA llTim eZone Ids(); 154. Str ing n owDat eTime =dat e2Str ing("yyyy-MM-dd HH:m m:ss"); 155. Sy stem.out.p rintl n("Th e tim e Asi a/Sha nhaiis "+ now DateT ime);//程序本地运行所在时区为[A sia/S hanha i] 156. //显示世界每个时区当前的实际时间157. for(int i=0;i<ids.lengt h;i++){ 158. Sys tem.o ut.pr intln(" *" + i ds[i] + "="+ s tring2Time zoneD efaul t(now DateT ime,i ds[i])); 159. } 160. //显示程序运行所在地的时区161.Sys tem.o ut.pr intln("Tim eZone.getD efaul t().g etID()=" +TimeZ one.g etDef ault().get ID()); 162. }163. 164. /**165. *将日期时间字符串根据转换为指定时区的日期时间. 166.* 167.* @par am sr cForm ater168. * 待转化的日期时间的格式.169. *@para m src DateT ime 170.* 待转化的日期时间. 171.* @par am ds tForm ater172. * 目标的日期时间的格式.173. * @param dstT imeZo neId174. * 目标的时区编号. 175.*176. *@retu rn 转化后的日期时间. 177.*/178. pub lic s tatic Stri ng st ring2Timez one(S tring srcF ormat er, 179. St ringsrcDa teTim e, St ringdstFo rmate r, St ringdstTi meZon eId){ 180. if(srcF ormat er == null || "".equ als(s rcFor mater)) 181. ret urn n ull;182. if (s rcDat eTime == n ull || "".equal s(src DateT ime))183. retur n nul l; 184. if (dst Forma ter == nul l ||"".eq uals(dstFo rmate r)) 185. re turnnull;186. if (dstTi meZon eId == nul l ||"".eq uals(dstTi meZon eId))187. retur n nul l; 188. Si mpleD ateFo rmatsdf = newSimpl eDate Forma t(src Forma ter);189. try{ 190. intdiffT ime = getD iffTi meZon eRawO ffset(dstT imeZo neId); 191. Date d =sdf.p arse(srcDa teTim e); 192. lo ng no wTime = d.getTi me();193. longnewNo wTime = no wTime - di ffTim e; 194. d = newDate(newNo wTime); 195. ret urn d ate2S tring(dstF ormat er, d); 196. }catch (Par seExc eptio n e){ 197. Log.outpu t(e.t oStri ng(), Log.STD_E RR);198. r eturn null; 199. } f inall y { 200. sd f = n ull;202. }203. 204. /**205. *获取系统当前默认时区与UTC的时间差.(单位:毫秒)206. *207. * @retur n 系统当前默认时区与UTC的时间差.(单位:毫秒)208. */209. priv ate s tatic intgetDe fault TimeZ oneRa wOffs et(){ 210. ret urn T imeZo ne.ge tDefa ult().getR awOff set(); 211. }212. 213. /**214. *获取指定时区与UTC的时间差.(单位:毫秒) 215.*216. *@para m tim eZone Id 217.*时区I d218. *@retu rn 指定时区与UT C的时间差.(单位:毫秒) 219.*/ 220. pr ivate stat ic in t get TimeZ oneRa wOffs et(St ringtimeZ oneId) { 221. r eturn Time Zone.getTi meZon e(tim eZone Id).g etRaw Offse t();222. } 223.224. /**225. * 获取系统当前默认时区与指定时区的时间差.(单位:毫秒)226. * 227. * @p aramtimeZ oneId228. * 时区Id229. * @r eturn系统当前默认时区与指定时区的时间差.(单位:毫秒) 230. */231. priv ate s tatic intgetDi ffTim eZone RawOf fset(Strin g tim eZone Id) {232. retu rn Ti meZon e.get Defau lt().getRa wOffs et()233. -TimeZ one.g etTim eZone(time ZoneI d).ge tRawO ffset(); 234. } 235.236. /** 237.* 将日期时间字符串根据转换为指定时区的日期时间.238. * 239. * @p aramsrcDa teTim e240. *待转化的日期时间.241. * @param dstT imeZo neId242. * 目标的时区编号. 243.*244. *@retu rn 转化后的日期时间. 245.* @see #str ing2T imezo ne(St ring, Stri ng, S tring, Str ing)247.p ublic stat ic St ringstrin g2Tim ezone Defau lt(St ringsrcDa teTim e, 248. Str ing d stTim eZone Id) {249. retu rn st ring2Timez one("yyyy-MM-dd HH:m m:ss", src DateT ime,250. "y yyy-M M-ddHH:mm:ss", dstT imeZo neId); 251. }252. 253.}。
ofepochsecond 方法
ofepochsecond 方法ofEpochSecond 方法是Java中的一个时间处理方法,它用于将时间戳转换为具体的时间。
时间戳是指从某个特定的时间点(通常是1970年1月1日00:00:00 UTC)开始计算的秒数,它可以精确到毫秒级别。
在Java中,时间戳以long类型表示,单位是秒。
而使用ofEpochSecond方法可以将这个长整型的时间戳转换为一个具体的时间。
该方法属于Java 8中的新特性,通过它可以方便地进行时间戳和日期之间的转换。
使用ofEpochSecond方法非常简单,只需将时间戳作为参数传入即可。
以下是一个示例:```long timestamp = 1623724800; // 时间戳为2021-06-15 00:00:00LocalDateTime dateTime = LocalDateTime.ofEpochSecond(timestamp, 0, ZoneOffset.UTC);System.out.println(dateTime); // 输出:2021-06-15T00:00```在上述示例中,我们将时间戳1623724800作为参数传入ofEpochSecond方法,同时指定了时区为UTC。
然后,方法会返回一个LocalDateTime对象,表示该时间戳对应的具体时间。
最后,我们通过打印输出来验证转换结果。
需要注意的是,ofEpochSecond方法的第二个参数是一个表示纳秒的long类型值。
在示例中,我们将其设置为0,表示忽略纳秒部分。
而第三个参数则用于指定时区,这里我们选择了UTC时区。
除了将时间戳转换为具体时间,ofEpochSecond方法还可以进行反向操作,即将具体时间转换为时间戳。
这是通过toEpochSecond方法实现的,它接受一个ZoneOffset参数来指定时区。
以下是一个示例:```LocalDateTime dateTime = LocalDateTime.of(2021, 6, 15, 0, 0); long timestamp = dateTime.toEpochSecond(ZoneOffset.UTC); System.out.println(timestamp); // 输出:1623724800```在上述示例中,我们首先使用LocalDateTime的of方法创建了一个表示2021年6月15日00:00的对象。
java处理节假日和工作时间的工具类
java处理节假⽇和⼯作时间的⼯具类import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.ArrayList;import java.util.Calendar;import java.util.Date;import java.util.List;/*** 节假⽇⼯作时间处理* 假⽇只处理今年、去年的 1.1、5.1、10.1,和周末*/public class HolidayUtil {private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");private static SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");private static List<String> holidays = new ArrayList<String>();/*** 静态块初始化法定节⽇*/static {Calendar c = Calendar.getInstance();holidays.add(c.get(Calendar.YEAR)-1 + "-01-01");holidays.add(c.get(Calendar.YEAR)-1 + "-05-01");holidays.add(c.get(Calendar.YEAR)-1 + "-10-01");holidays.add(c.get(Calendar.YEAR) + "-01-01");holidays.add(c.get(Calendar.YEAR) + "-05-01");holidays.add(c.get(Calendar.YEAR) + "-10-01");}/*** 判断当天是否是节假⽇节⽇只包含1.1;5.1;10.1** @param date 时间* @return ⾮⼯作时间:true;⼯作时间:false*/public static boolean isHolidayOrFestival(Date date) {boolean result = false;boolean isHolidayTmp = isHoliday(date);if (isHolidayTmp) {result = true;} else {Calendar c = Calendar.getInstance();c.setTime(date);//周末直接为⾮⼯作时间if (c.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY || c.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY) { result = true;} else {//周内9点到17:30为⼯作时间int hour = c.get(Calendar.HOUR_OF_DAY);int minute = c.get(Calendar.MINUTE);if (hour < 9 || (hour == 17 && minute > 30) || hour >= 18) {result = true;}}}return result;}/*** ⾮⼯作时间获取最近的⼯作时间* @param date 时间* @return 返回处理后时间,格式:yyyy-MM-dd HH:mm:ss*/public static String getPreWorkDay(Date date) {Calendar c = Calendar.getInstance();c.setTime(date);if (!isHolidayOrFestival(date)) {return datechange(date, "yyyy-MM-dd HH:mm:ss");}//如果是周⽇最近的⼯作⽇为周五,⽇期减去2if (c.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) {c.add(Calendar.DAY_OF_MONTH, -2);}//如果是周六最近的⼯作⽇为周五,⽇期减去1else if (c.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY) {c.add(Calendar.DAY_OF_MONTH, -1);}//如果是周⼀,并且为早上9点之前,最近的⼯作⽇为周五,⽇期减去3else if (c.get(Calendar.DAY_OF_WEEK) == Calendar.MONDAY) {int hour = c.get(Calendar.HOUR_OF_DAY);if (hour < 9) {c.add(Calendar.DAY_OF_MONTH, -3);}}else{int hour = c.get(Calendar.HOUR_OF_DAY);if (hour < 9) {c.add(Calendar.DAY_OF_MONTH, -1);}}c.set(Calendar.HOUR_OF_DAY, 17);c.set(Calendar.MINUTE, 30);c.set(Calendar.SECOND, 0);return datechange(c.getTime(), "yyyy-MM-dd HH:mm:ss"); }public static String datechange(Date date, String pattern) { SimpleDateFormat sdf = new SimpleDateFormat(pattern); String demo = sdf.format(date);return demo;}/*** 根据判断当前时间是否是节⽇** @param date* 时间* @return*/private static boolean isHoliday(Date date) {boolean result = false;String dateStr = sdf.format(date);if (holidays.size() > 0) {for (String holiday : holidays) {if (holiday.equals(dateStr)) {result = true;break;}}}return result;}public static void main(String[] args) throws ParseException { String d = "2017-07-20 18:31:58";System.out.println(getPreWorkDay(sdf1.parse(d)));}}。
Java时间戳处理
时间戳计算
// 当前时刻的前一小时时间戳 long resTimeStamp = curTimeStamp - hour;
今天零点的时间戳
long time1 = System.currentTimeMillis(); long zero = time1/(1000*3600*24)*(1000*3600*24) - TimeZone.getDefault().getRawOffset();
获取当前时间戳
long curTimeStamp = System.currentTimeMillis();
时间戳转字符串
long curTimeStamp = System.currentTimeMillis(); Date date = new Date(curTimeStamp); SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss"); String stringDate = sdf.format(date);
时间戳常量
private final static long second = 1000; private final static long minute = 60000; private final static long hour = 3600000; private final static long day = 86400000; private final static long month = 2592000000L; private final static long year = 31104000000L;
unix时间戳是从1970年1月1日utcgmt的午夜开始所经过的秒数其值从0开始按照iso8601规范为Java时 Nhomakorabea 戳 处 理
java实现当前时间加减30分钟的时间代码
java实现当前时间加减30分钟的时间代码如代码所⽰:SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");Date now = new Date();System.out.println("当前时间:" + sdf.format(now));⽅法⼀:long time = 30*60*1000;//30分钟Date afterDate = new Date(now .getTime() + time);//30分钟后的时间Date beforeDate = new Date(now .getTime() - time);//30分钟前的时间System.out.println(sdf.format(afterDate ));System.out.println(sdf.format(beforeDate));⽅法⼆:Calendar nowTime = Calendar.getInstance();nowTime.add(Calendar.MINUTE, 30);//30分钟后的时间System.out.println(sdf.format(nowTime.getTime()));Calendar nowTime2 = Calendar.getInstance();nowTime2.add(Calendar.MINUTE, -30);//30分钟前的时间System.out.println(sdf.format(nowTime2.getTime()));Date1.after(Date2),当Date1⼤于Date2时,返回TRUE,当⼩于等于时,返回false;Date1.before(Date2),当Date1⼩于Date2时,返回TRUE,当⼤于等于时,返回false;如果业务数据存在相等的时候,⽽且相等时也需要做相应的业务判断或处理时,请注意。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
两个GregorianCalendar的构造函数可以用来处理时间。前者创建一个表示日期,小时和分钟的对象:
GregorianCalendar(int year, int month, int date, int hour, int minute)
Java的时间处理(续<计算Java时间>)
学习在java中计算基本的时间段
概述
如果你知道怎样在java中使用日期,那么使用时间和它才不多一样简单。这篇文章告诉你怎样把他们的差别联系起来。Robert Nielsen还告诉你怎样使用java来计算抵达航班和制造过程的时间。
作者:Robert Nielsen
long difference = l2 - l1;
System.out.println("Elapsed milliseconds: " + difference);
}
}
上面的程序打印如下:
Elapsed milliseconds: 1000
上面的程序甚至在时间少于一个小时也可以正确的计算小时数。例如,你用上面的程序计算1,000秒,输出入下:
0 hour(s) 16 minute(s) 40 second(s)
举一个现实世界的例子,下面的程序计算阿波罗11飞到月球使用得时间:
import java.util.*;
public class LunarLanding {
long seconds = 1999 / 1000;
这种方法舍去小数部分转换毫秒到秒,所以1,999毫秒等于1秒,2,000毫秒等于2秒。
计算更大的单位-例如天数,小时和分钟-给定一个时间数值,可以使用下面的过程:
1. 计算最大的单位,减去这个数值的秒数
2. 计算第二大单位,减去这个数值的秒数
第二个创建一个表示一个日期,小时,分钟和秒:
GregorianCalendar(int year, int month, int date, int hour, int minute, int second)
首先,我应该提醒一下,每一个构造函数需要时间信息中的日期信息(年,月,日)。如果你想说2:30 p.m.,你必须指出日期。
2. Date类的构造函数Date()返回代表当前创建的时刻的对象。Date的方法getTime()返回一个long值在数值上等于1970年1月1日之前或之后的时刻。
3. DateFormat类用来转换Date到String,反之亦然。静态方法getDateInstance()返回DateFormat的缺省格式;getDateInstance(DateFormat.FIELD)返回指定的DateFormat对象格式。Format(Date d)方法返回String表示日期,例如"January 1,2002."反过来,parse(String s)方法返回以参数字符串表示的Date对象。
Date d = liftOffApollo11.getTime();
DateFormat df1 = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM);
DateFormat df2 = DateFormat.getTimeInstance(DateFormat.SHORT);
GregorianCalendar gc1 = new GregorianCalendar(1995, 11, 1, 3, 2, 1);
GregorianCalendar gc2 = new GregorianCalendar(1995, 11, 1, 3, 2, 2);
同样,每一个GregorianCalendar构造函数创建一个在时间上使用毫秒计算的对象。所以,如果你的构造函数只提供年,月,日参数,那小时,分钟,秒和毫秒的值将被置0.
DateFormat和时间
你可以使用静态方法getDateTimeInstance(int dateStyle,int timeStyle)来建立DateFormat对象来显示时间和日期。这个方法表明你想要的日期和时间格式。如果你喜欢使用缺省格式,可以使用getDateTimeInstance()来代替它。
long l2 = d2.getTime();
long difference = Math.abs(l2 - l1);
return difference / 1000;
}
public void calcHM(long timeInSeconds) {
翻译:Cocia Lin
这篇文章是在我发表过的<计算Java时间>(译者:已经翻译完成)的基础上的。在这里,我列出那篇文章几个你应该熟悉得关键点。如果这几点你不太清楚,我建议你读一下<计算Java时间>,了解一下。
1. Java计算时间依靠1970年1月1日开始的毫秒数.
public class Apollo {
public static void main(String[] args) {
GregorianCalendar liftOffApollo11 = new GregorianCalendar(1969, Calendar.JULY, 16, 9, 32);
这个程序也带来一点混淆。GregorianCalendar类的getTime()返回一个Date对象,Date类的getTime()方法返回从1970年1月1日到这个时间的long类型的毫秒数值。虽然他们的方法名字相同,返回值却不一样!
下面的程序片断用简单的整数除法转换毫秒到秒:
long milliseconds = 1999;
// the above two dates are one second apart
Date d1 = gc1.getTime();
Date d2 = gc2.getTime();
long l1 = d1.getTime();
long l2 = d2.getTime();
将2,800秒转换成分钟,2,800除以60。使用整数除法,答案是46。2,800 - (60 x 46) = 40秒。最后答案是2小时,46分,40秒。
下面的Java程序使用上面的计算方法:
import java.util.*;
public class Elapsed1 {
public void calcHMS(int timeInSeconds) {
你可以使用静态方法getTimeInstance(int timeStyle)创建DateFormat对象来显示正确的时间。
下面的程序示范了getDateTimeInstance()和getTimeInstance()怎样工作:
import java.util.*;
import java.text.*;
将问题复杂化,人类至少是用两种方法计算时间。你可以说一天已经结束当24小时过去了,或者日历从今天翻到明天。我们将讨论我们想到的这两种情况。
时间段,情况 1:严格时间单位
在这种情况中,只有24小时过去,这天才过去,60分钟过去,这个小时才过去,60秒过去,这个分钟才过去,以此类推。在这个方法中,23小时的时间将被认为是0天。
public long getElapsedSeconds(GregorianCalendar gc1, GregorianCalendar gc2) {
Date d1 = gc1.getTime();
Date d2 = gc2.getTime();
long l1 = d1.getTime();
4. format()方法返回的字符串格式根据不同地区的时间设置而有所不同。
5. GregorianCalendear类有两个重要的构造函数:GregorianCalerdar(),返回代表当前创建时间的对象;GregorianCalendar(int year,int month,int date)返回代表任意日期的对象。GregorianCalendar类的getTime()方法返回日期对象。Add(int field,int amount)方法通过加或减时间单位,象天数,月数或年数来计算日期。
int hours, minutes, seconds;
hours = timeInSeconds / 3600;
timeInSeconds = timeInSeconds - (hours * 3600);
minutes = timeInSeconds / 60;
Jul 16, 1969 9:32:00 AM
9:32 AM
(输出根据你所在得地区有所不同)
计算时间间隔
你可能有时需要计算过去的时间;例如,给你开始和结束时间,你想知道制造流程的持续时间。一个出租公司按小时或天数出租东西,计算时间对他们也很有用。同样的,在金融界,经常需要计算重要的支付时间。
}
public static void main(String[] args) {
Elapsed1 elap = new Elapsed1();
elap.calcHMS(10000); } Nhomakorabea}
输出结果如下:
2 hour(s) 46 minute(s) 40 second(s)
long hours, minutes, seconds;
hours = timeInSeconds / 3600;
使用这种方法计算时间段,你从计算过去的毫秒开始。为了做到这一点,首先转换每个日期为从1970年1月1日起得毫秒数。你可以从第二个毫秒值中减去第一个毫秒值。这里有一个简单的计算: