下载文档原格式
在开始撰写文章之前，我首先需要对Java计算状态持续时间算法进行全面评估。
这个主题涉及到Java编程中的算法设计和应用，它是一个具有挑战性和价值的话题。
我会按照你的要求，从简到繁地探讨这个主题，以使你能够更深入地理解。
1. Java计算状态持续时间算法在Java编程中，状态持续时间算法是指在给定一系列事件或状态的情况下，计算状态持续时间的算法。
这个算法在实际应用中有着广泛的用途，比如在工程、生产、金融等领域。
它可以帮助我们更好地理解和分析事件发生的持续时间，从而做出更准确的决策。
2. 算法原理状态持续时间算法的原理是通过对一系列事件或状态的时间戳进行计算，从而得出每个状态的持续时间。
这涉及到对时间的比较和计算，以及对事件序列的处理。
在Java中，我们可以利用时间类和数据结构来实现这个算法，从而高效地计算状态持续时间。
3. 算法设计与实现在设计状态持续时间算法时，我们需要考虑到事件序列的处理效率和算法的准确性。
可以采用动态规划、滑动窗口或者时间序列分析等方法来设计算法，以满足不同的需求。
在Java中，我们可以利用多线程、数据流处理等技术来实现状态持续时间算法，从而提高算法的性能和扩展性。
4. 应用与实践状态持续时间算法在实际应用中有着广泛的用途。
比如在生产管理中，可以利用这个算法来分析设备运行的持续时间，从而制定更合理的维护计划。
在金融领域，可以利用这个算法来分析交易行为的持续时间，从而提高交易策略的准确性。
在工程领域，可以利用这个算法来分析故障发生的持续时间，从而改进设备的设计和维护方式。
总结与展望通过对Java计算状态持续时间算法的全面评估，我们可以更好地理解和应用这个算法。
它不仅在计算机科学领域有着重要的意义，而且在实际应用中也有着广泛的用途。
我个人认为，随着人工智能和大数据技术的发展，这个算法将会得到更广泛的应用和研究。
我们可以期待它在更多领域的发展和创新。
5. 算法的优化与性能提升在实际应用中，状态持续时间算法的性能和准确性是至关重要的。
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中计算两个⽇期间的天数，⼤致有2种⽅法：⼀是使⽤原⽣JDK进⾏计算，在JDK8中提供了更为直接和完善的⽅法；⼆是使⽤第三⽅库。
1、使⽤原⽣的JDK[java]1. private static long daysBetween(Date one, Date two) {2. long difference = (one.getTime()-two.getTime())/86400000;3. return Math.abs(difference);4. }private static long daysBetween(Date one, Date two) {long difference = (one.getTime()-two.getTime())/86400000;return Math.abs(difference);}这种⽅式由于计算简单，为⼴⼤开发⼈员所采⽤。
注意：由于转换成毫秒数计算，如果要获得较为准确的结果，应将⽇期规整，即将⽇期的时分秒设置为0:00点整点，避免2⽇期时间（时分秒）的差异造成计算偏差。
参考代码：[java]1. import java.text.SimpleDateFormat;2. import java.util.Date;3.4. public class DateTest {5. private int getTermDays2() throws Exception{6. String sEndDate = "2018-03-01";7. SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");8. Date date1 = new Date();9. Date date2 = sdf.parse(sEndDate);10. long days = (date2.getTime() - date1.getTime()) / (24*3600*1000);11. long yushu = (date2.getTime() - date1.getTime()) % (24*3600*1000);12.13. System.out.println("days:" + days + ",yushu:" + yushu);14.15. //规整⽅法116. date1.setHours(0);17. date1.setMinutes(0);18. date1.setSeconds(0);19. long days2 = (date2.getTime() - date1.getTime()) / (24*3600*1000);20. long yushu2 = (date2.getTime() - date1.getTime()) % (24*3600*1000);21.22. System.out.println("days2:" + days2 + ",yushu2:" + yushu2);23.24. //规整⽅法225. String sdate1 = sdf.format(date1);26. date1 = sdf.parse(sdate1);27.28. long days3 = (date2.getTime() - date1.getTime()) / (24*3600*1000);29. long yushu3 = (date2.getTime() - date1.getTime()) % (24*3600*1000);30.31. System.out.println("days3:" + days3 + ",yushu3:" + yushu3);32.33. return (int)days;34. }35.36. public static void main(String[] args) {37. DateTest dt = new DateTest();38. try {39. dt.getTermDays2();40. } catch (Exception e) {41. e.printStackTrace();42. }43. }44.45. }import java.text.SimpleDateFormat;import java.util.Date;public class DateTest {private int getTermDays2() throws Exception{String sEndDate = "2018-03-01";SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");Date date1 = new Date();Date date2 = sdf.parse(sEndDate);long days = (date2.getTime() - date1.getTime()) / (24*3600*1000);long yushu = (date2.getTime() - date1.getTime()) % (24*3600*1000);System.out.println("days:" + days + ",yushu:" + yushu);//规整⽅法1date1.setHours(0);date1.setMinutes(0);date1.setSeconds(0);long days2 = (date2.getTime() - date1.getTime()) / (24*3600*1000);long yushu2 = (date2.getTime() - date1.getTime()) % (24*3600*1000);System.out.println("days2:" + days2 + ",yushu2:" + yushu2);//规整⽅法2String sdate1 = sdf.format(date1);date1 = sdf.parse(sdate1);long days3 = (date2.getTime() - date1.getTime()) / (24*3600*1000);long yushu3 = (date2.getTime() - date1.getTime()) % (24*3600*1000);System.out.println("days3:" + days3 + ",yushu3:" + yushu3);return (int)days;}public static void main(String[] args) {DateTest dt = new DateTest();try {dt.getTermDays2();} catch (Exception e) {e.printStackTrace();}}}规整⽅法1⽆法消除毫秒数的影响，结果差1天；规整⽅法1则可较好地消除时间对天数计算的影响。
【java 根据时间段记录计算时长的方法】一、时间的重要性时间是一种珍贵的资源，在生活和工作中都扮演着重要的角色。
在编程中，对时间的使用也是必不可少的，特别是在需要记录和计算时间长度的场景下。
而在Java中，如何根据时间段记录并计算时长，是一个常见且重要的问题。
在本文中，我将探讨这个主题，并提供一些解决方案和建议。
二、通过时间戳记录时间段1. 时间戳的概念在Java中，时间戳是一种以毫秒为单位的表示时间的方式，可以通过System.currentTimeMillis()方法获取当前时间的时间戳。
时间戳可以精确地表示一个时间点，也可以用来计算时间长度。
2. 记录时间段的开始和结束时间戳要记录一个时间段的时长，首先需要获取开始和结束时间点的时间戳。
在实际应用中，可以使用System.currentTimeMillis()方法来获取当前时间戳，并将其保存下来作为开始时间戳；同样地，当时间段结束时也需要获取一个结束时间戳。
3. 计算时长有了开始时间戳和结束时间戳后，就可以很容易地计算出时间段的时长。
通过简单地相减操作，即可得到时间段的时长，然后可以将其转换成所需的时间单位，如秒、分钟或小时。
三、使用Java 8的Time API记录时间段1. Java 8的Time APIJava 8引入了新的时间日期API，位于java.time包下，提供了更加灵活、方便的时间处理方式。
在使用Java 8的Time API记录时间段时，可以使用LocalDateTime类来表示时间点，Duration类来表示时长。
2. 记录时间段的开始和结束时间点使用LocalDateTime类可以轻松地表示时间段的开始和结束时间点，同时Duration类可以计算时间段的时长。
可以通过LocalDateTime.now()获取当前时间点，并将其保存下来作为开始时间；在时间段结束时也需要获取一个结束时间。
3. 计算时长通过Duration.between()方法可以计算出时间段的时长，得到一个Duration对象，然后可以调用toMinutes()、toHours()等方法将时间段转换成所需的时间单位。
java时间戳、时间差计算（秒、分钟、⼩时、天数、⽉份、年）以下代码就是时间差计算（秒、分钟、⼩时、天数、⽉份、年）package me.zhengjie;import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Date;import org.junit.Test;public class DemoTest {@Testpublic void run1() {System.out.println("run1()");SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");String startDateStr = "2012-01-20 00:00:00.000";String endDateStr = "2019-11-01 00:00:00.000";try {Date startDate = sdf.parse(startDateStr);Date endDate = sdf.parse(endDateStr);String timeDifference = this.convert(startDate, endDate);System.out.println(timeDifference);} catch (ParseException e) {e.printStackTrace();System.out.println("⽇期格式化失败");}}public String convert(Date startDate,Date endDate) {long startTime = startDate.getTime();//获取毫秒数long endTime = endDate.getTime(); //获取毫秒数long timeDifference = endTime-startTime;long second = timeDifference/1000; //计算秒if(second<60) {return second+"秒前";}else {long minute = second/60;if(minute<60) {return minute+"分钟前";}else {long hour = minute/60;if(hour<24) {return hour+"时前";}else {long day = hour/24;if(day<30) {return day+"天前";}else {long month = day/30;if(month<12) {return day+"⽉前";}else {long year = month/12;return year+"年前";}}}}}}}。
Java对⽇期Date类进⾏加减运算、年份加减⽉份加减、时间差等等实现代码⼀：import java.text.SimpleDateFormat;import java.util.Calendar;import java.util.Date;public class DateTestUtil {public static void main(String[] args) throws Exception {SimpleDateFormat sdf=new SimpleDateFormat("yyyyMMdd");String str="20110823";Date dt=sdf.parse(str);Calendar rightNow = Calendar.getInstance();rightNow.setTime(dt);rightNow.add(Calendar.YEAR,-1);//⽇期减1年rightNow.add(Calendar.MONTH,3);//⽇期加3个⽉rightNow.add(Calendar.DAY_OF_YEAR,10);//⽇期加10天Date dt1=rightNow.getTime();String reStr = sdf.format(dt1);System.out.println(reStr);}}注：在Calendar对象的add⽅法中，第⼆个参数为正数表⽰“加”，负数表⽰“减”。
代码⼆： java date ⽇期加减天数测试类代码：import java.text.SimpleDateFormat;import java.util.Date;public class DateTest {public static void main(String[] arg){Date now = new Date();addAndSubtractDaysByGetTime(now,-5);addAndSubtractDaysByGetTime(now,5);addAndSubtractDaysByCalendar(now,-5);addAndSubtractDaysByCalendar(now,5);}public static Date addAndSubtractDaysByGetTime(Date dateTime/*待处理的⽇期*/,int n/*加减天数*/){//⽇期格式SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd");SimpleDateFormat dd=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");System.out.println(df.format(new Date(dateTime.getTime() + n * 24 * 60 * 60 * 1000L)));//System.out.println(dd.format(new Date(dateTime.getTime() + n * 24 * 60 * 60 * 1000L)));//注意这⾥⼀定要转换成Long类型，要不n超过25时会出现范围溢出，从⽽得不到想要的⽇期值return new Date(dateTime.getTime() + n * 24 * 60 * 60 * 1000L);}public static Date addAndSubtractDaysByCalendar(Date dateTime/*待处理的⽇期*/,int n/*加减天数*/){//⽇期格式SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd");SimpleDateFormat dd=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");java.util.Calendar calstart = java.util.Calendar.getInstance();calstart.setTime(dateTime);calstart.add(java.util.Calendar.DAY_OF_WEEK, n);System.out.println(df.format(calstart.getTime()));//System.out.println(dd.format(calstart.getTime()));return calstart.getTime();}}运⾏结果：2014-10-062014-10-162014-10-062014-10-16代码三：在⽹上查阅资料，加上⾃⼰总结的⼀些关于Date类的⼯具类。
java延时处理方法Java中的延时处理是指在程序中设置某个操作或任务在一定的时间间隔之后才执行。
延时处理在很多场景中都非常有用，比如定时任务、动画效果、用户交互等。
本文将介绍几种常见的Java延时处理方法。
一、Thread.sleep()方法Thread.sleep()方法是Java中最简单的延时处理方法之一。
它会使当前线程暂停执行指定的毫秒数。
示例代码如下：```javatry {Thread.sleep(1000); // 暂停1秒} catch (InterruptedException e) {e.printStackTrace();}```需要注意的是，Thread.sleep()方法会抛出InterruptedException 异常，因此需要进行异常处理。
二、Timer定时器Timer是Java中提供的一个定时器工具类，可以用来实现延时处理。
示例代码如下：```javaTimer timer = new Timer();timer.schedule(new TimerTask() {@Overridepublic void run() {// 需要延时执行的任务}}, 1000); // 延时1秒后执行```Timer.schedule()方法接受一个TimerTask对象和延时时间作为参数，通过重写TimerTask的run()方法来实现延时执行的任务。
需要注意的是，Timer在执行定时任务时是单线程的，如果某个任务执行时间过长，会影响其他任务的执行。
三、ScheduledExecutorService定时器ScheduledExecutorService是Java中提供的一个可以替代Timer 的定时器工具类，它可以更好地处理任务的延时和周期执行。
示例代码如下：```javaScheduledExecutorService executorService = Executors.newScheduledThreadPool(1); executorService.schedule(new Runnable() {@Overridepublic void run() {// 需要延时执行的任务}}, 1000, LISECONDS); // 延时1秒后执行```ScheduledExecutorService.schedule()方法接受一个Runnable 对象和延时时间作为参数，通过重写Runnable的run()方法来实现延时执行的任务。
Java计算两个⽇期的时间间隔不多说，直接上代码1、利⽤SimpleDateFormat类，获取天数间隔代码：import java.text.DateFormat;import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Date;/*** 利⽤SimpleDateFormat类计算两个时间的天数间隔* @throws ParseException*/public class CalculateDaysInterval1 {public static void main(String[] args) throws ParseException {// ⽇期格式化DateFormat simpleFormat = new SimpleDateFormat("yyyy-MM-dd");Date startDate = simpleFormat.parse("2021-03-01");Date endDate = simpleFormat.parse("2021-07-08");long startTime = startDate.getTime();long endTime = endDate.getTime();int days = (int) ((endTime - startTime) / (1000 * 60 * 60 * 24));System.out.println("两个时间之间的天数间隔为：" + days);}}输出结果：两个时间之间的天数间隔为：1292、利⽤Java 8中ChronoUnit类，获取天数间隔代码：import java.time.LocalDate;import java.time.temporal.ChronoUnit;/*** 利⽤ChronoUnit类计算两个时间的天数间隔*/public class CalculateDaysInterval2 {public static void main(String[] args) {LocalDate startDate = LocalDate.of(2021, 3, 1);LocalDate endDate = LocalDate.of(2021, 7, 8);long days = ChronoUnit.DAYS.between(startDate, endDate);System.out.println("两个时间之间的天数间隔为：" + days);}}输出结果：两个时间之间的天数间隔为：1293.1、利⽤getTime()，获取时分秒间隔public static void main(String[] args) throws ParseException {String str1 = "2021-09-09 03:30:16";String str2 = "2021-09-09 13:31:19";DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");Date firstTime = df.parse(str1);Date currentTime = df.parse(str2);System.out.println(getTimeInterval(currentTime, firstTime));}/*** 获取时间差⽅法,返回时分秒 HH:mm:ss** @param currentTime* @param firstTime* @return*/public static String getTimeInterval(Date currentTime, Date firstTime) {DecimalFormat decimalFormat = new DecimalFormat("00");long diff = currentTime.getTime() - firstTime.getTime();//得到的差值long hours = diff / (1000 * 60 * 60); //获取时long minutes = (diff - hours * (1000 * 60 * 60)) / (1000 * 60); //获取分钟long s = (diff / 1000 - hours * 60 * 60 - minutes * 60);//获取秒String countTime = "" + decimalFormat.format(hours) + ":" + decimalFormat.format(minutes) + ":" + decimalFormat.format(s);return countTime;}输出结果：3.2、利⽤getTime()，获取年⽉⽇时分秒间隔public static void main(String[] args) throws ParseException {String str1 = "2020-05-29 03:30:16";String str2 = "2021-09-09 13:31:19";DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");Date firstTime = df.parse(str1);Date currentTime = df.parse(str2);System.out.println(getTimeInterval(currentTime, firstTime));}/*** 获取时间差⽅法,返回年⽉⽇时分秒某年某⽉某⽇某时某分某秒** @param currentTime* @param firstTime* @return*/public static String getTimeInterval(Date currentTime, Date firstTime) {// 得到的时间差值, 微秒级别long diff = currentTime.getTime() - firstTime.getTime();Calendar currentTimes = dataToCalendar(currentTime);//当前系统时间转Calendar类型Calendar firstTimes = dataToCalendar(firstTime);//查询的数据时间转Calendar类型int year = currentTimes.get(Calendar.YEAR) - firstTimes.get(Calendar.YEAR);//获取年int month = currentTimes.get(Calendar.MONTH) - firstTimes.get(Calendar.MONTH);int day = currentTimes.get(Calendar.DAY_OF_MONTH) - firstTimes.get(Calendar.DAY_OF_MONTH);if (day < 0) {month -= 1;currentTimes.add(Calendar.MONTH, -1);day = day + currentTimes.getActualMaximum(Calendar.DAY_OF_MONTH);//获取⽇}if (month < 0) {month = (month + 12) % 12;//获取⽉year--;}long days = diff / (1000 * 60 * 60 * 24);long hours = (diff - days * (1000 * 60 * 60 * 24)) / (1000 * 60 * 60);//获取时long minutes = (diff - days * (1000 * 60 * 60 * 24) - hours * (1000 * 60 * 60)) / (1000 * 60);//获取分钟long s = (diff / 1000 - days * 24 * 60 * 60 - hours * 60 * 60 - minutes * 60);//获取秒String CountTime = "" + year + "年" + month + "⽉" + day + "天 " + hours + "时" + minutes + "分" + s + "秒";return CountTime;}// Date类型转Calendar类型public static Calendar dataToCalendar(Date date) {Calendar calendar = Calendar.getInstance();calendar.setTime(date);return calendar;}输出结果：。
经常看见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的时间处理(续<计算Java时间>)学习在java中计算基本的时间段概述如果你知道怎样在java中使用日期，那么使用时间和它才不多一样简单。
这篇文章告诉你怎样把他们的差别联系起来。
Robert Nielsen还告诉你怎样使用java来计算抵达航班和制造过程的时间。
作者：Robert Nielsen翻译：Cocia Lin这篇文章是在我发表过的<计算Java时间>(译者:已经翻译完成)的基础上的。
在这里，我列出那篇文章几个你应该熟悉得关键点。
如果这几点你不太清楚，我建议你读一下<计算Java 时间>，了解一下。
1. Java计算时间依靠1970年1月1日开始的毫秒数.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对象。
4. format()方法返回的字符串格式根据不同地区的时间设置而有所不同。
5. GregorianCalendear类有两个重要的构造函数：GregorianCalerdar(),返回代表当前创建时间的对象；GregorianCalendar(int year,int month,int date)返回代表任意日期的对象。
GregorianCalendar类的getTime()方法返回日期对象。
Add(int field,int amount)方法通过加或减时间单位，象天数，月数或年数来计算日期。
GregorianCalendar和时间两个GregorianCalendar的构造函数可以用来处理时间。
前者创建一个表示日期，小时和分钟的对象：GregorianCalendar(int year, int month, int date, int hour, int minute)第二个创建一个表示一个日期，小时，分钟和秒：GregorianCalendar(int year, int month, int date, int hour, int minute, int second)首先，我应该提醒一下，每一个构造函数需要时间信息中的日期信息(年，月，日)。
如果你想说2:30 p.m.,你必须指出日期。
同样，每一个GregorianCalendar构造函数创建一个在时间上使用毫秒计算的对象。
所以，如果你的构造函数只提供年，月，日参数，那小时，分钟，秒和毫秒的值将被置0. DateFormat和时间你可以使用静态方法getDateTimeInstance(int dateStyle,int timeStyle)来建立DateFormat对象来显示时间和日期。
这个方法表明你想要的日期和时间格式。
如果你喜欢使用缺省格式，可以使用getDateTimeInstance()来代替它。
你可以使用静态方法getTimeInstance(int timeStyle)创建DateFormat对象来显示正确的时间。
下面的程序示范了getDateTimeInstance()和getTimeInstance()怎样工作：import java.util.*;import java.text.*;public class Apollo {public static void main(String[] args) {GregorianCalendar liftOffApollo11 = new GregorianCalendar(1969, Calendar.JULY, 16, 9, 32);Date d = liftOffApollo11.getTime();DateFormat df1 = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM);DateFormat df2 = DateFormat.getTimeInstance(DateFormat.SHORT);String s1 = df1.format(d);String s2 = df2.format(d);System.out.println(s1);System.out.println(s2);}}在我的电脑上，上面的程序显示如下：Jul 16, 1969 9:32:00 AM9:32 AM(输出根据你所在得地区有所不同)计算时间间隔你可能有时需要计算过去的时间；例如，给你开始和结束时间，你想知道制造流程的持续时间。
一个出租公司按小时或天数出租东西，计算时间对他们也很有用。
同样的，在金融界，经常需要计算重要的支付时间。
将问题复杂化，人类至少是用两种方法计算时间。
你可以说一天已经结束当24小时过去了，或者日历从今天翻到明天。
我们将讨论我们想到的这两种情况。
时间段，情况1：严格时间单位在这种情况中，只有24小时过去，这天才过去，60分钟过去，这个小时才过去，60秒过去，这个分钟才过去，以此类推。
在这个方法中，23小时的时间将被认为是0天。
使用这种方法计算时间段，你从计算过去的毫秒开始。
为了做到这一点，首先转换每个日期为从1970年1月1日起得毫秒数。
你可以从第二个毫秒值中减去第一个毫秒值。
这里有一个简单的计算：import java.util.*;public class ElapsedMillis {public static void main(String[] args) {GregorianCalendar gc1 = new GregorianCalendar(1995, 11, 1, 3, 2, 1);GregorianCalendar gc2 = new GregorianCalendar(1995, 11, 1, 3, 2, 2);// the above two dates are one second apartDate d1 = gc1.getTime();Date d2 = gc2.getTime();long l1 = d1.getTime();long l2 = d2.getTime();long difference = l2 - l1;System.out.println("Elapsed milliseconds: " + difference);}}上面的程序打印如下：Elapsed milliseconds: 1000这个程序也带来一点混淆。
GregorianCalendar类的getTime()返回一个Date对象，Date类的getTime()方法返回从1970年1月1日到这个时间的long类型的毫秒数值。
虽然他们的方法名字相同，返回值却不一样！下面的程序片断用简单的整数除法转换毫秒到秒：long milliseconds = 1999;long seconds = 1999 / 1000;这种方法舍去小数部分转换毫秒到秒，所以1,999毫秒等于1秒，2,000毫秒等于2秒。
计算更大的单位-例如天数，小时和分钟-给定一个时间数值，可以使用下面的过程：1. 计算最大的单位，减去这个数值的秒数2. 计算第二大单位，减去这个数值的秒数3. 重复操作直到只剩下秒例如,如果你的时间的10,000秒，你想知道这个数值相应的是多少小时，多少分钟，多少秒，你从最大的单位开始：小时。
10,000除以3600（一个小时的秒数）得到小时数。
使用整数除法，答案是2小时（整数除法中小数舍去）计算剩下的秒数，10,000-(3,600 x 2) = 2,800秒。
所以你有2小时和2,800秒。
将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) {int hours, minutes, seconds;hours = timeInSeconds / 3600;timeInSeconds = timeInSeconds - (hours * 3600);minutes = timeInSeconds / 60;timeInSeconds = timeInSeconds - (minutes * 60);seconds = timeInSeconds;System.out.println(hours + " hour(s) " + minutes + " minute(s) " + seconds + " second(s)");}public static void main(String[] args) {Elapsed1 elap = new Elapsed1();elap.calcHMS(10000);}}输出结果如下：2 hour(s) 46 minute(s) 40 second(s)上面的程序甚至在时间少于一个小时也可以正确的计算小时数。
例如，你用上面的程序计算1,000秒，输出入下：0 hour(s) 16 minute(s) 40 second(s)举一个现实世界的例子，下面的程序计算阿波罗11飞到月球使用得时间：import java.util.*;public class LunarLanding {public long getElapsedSeconds(GregorianCalendar gc1, GregorianCalendar gc2) { Date d1 = gc1.getTime();Date d2 = gc2.getTime();long l1 = d1.getTime();long l2 = d2.getTime();long difference = Math.abs(l2 - l1);return difference / 1000;}public void calcHM(long timeInSeconds) {long hours, minutes, seconds;hours = timeInSeconds / 3600;timeInSeconds = timeInSeconds - (hours * 3600);minutes = timeInSeconds / 60;System.out.println(hours + " hour(s) " + minutes + " minute(s)" );}public static void main(String[] args) {GregorianCalendar lunarLanding = new GregorianCalendar(1969, Calendar.JULY, 20, 16,17);GregorianCalendar lunarDeparture = new GregorianCalendar(1969, Calendar.JULY, 21, 13, 54);GregorianCalendar startEVA = new GregorianCalendar(1969, Calendar.JULY, 20, 22, 56);GregorianCalendar endEVA = new GregorianCalendar(1969, Calendar.JULY, 21, 1, 9);LunarLanding apollo = new LunarLanding();long eva = apollo.getElapsedSeconds(startEVA, endEVA);System.out.print("EVA duration = ");apollo.calcHM(eva);long lunarStay = apollo.getElapsedSeconds(lunarLanding, lunarDeparture);System.out.print("Lunar stay = ");apollo.calcHM(lunarStay);}}上面程序输出如下：EVA duration = 2 hour(s) 13 minute(s)Lunar stay = 21 hour(s) 37 minute(s)目前为止，我们计算的基础公式是这样的：1分钟=60秒，1小时=60分，1天=24小时。
