Java中获取比毫秒更精确的时间

合集下载

java 根据时间段记录计算时长的方法

【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中获取比毫秒更精确的时间

] java中获取比毫秒更为精确的时间(2012-07-03 11:54:33)标签：分类：from:关键词：java 毫秒微秒纳秒System.currentTimeMillis() 误差在对新写的超快xml解析器和xpath引擎进行效率测试时，为获取执行时间，开始也没多想就用了System.currentTimeMillis() 来做的。

由此碰到一个极其诡异的问题，同样的代码循环执行数次，分析每一次的执行时间，发现一大部分执行时间为小于1毫秒，但其间也发现有相当一部分的执行时间有非常大的跳跃，而且时间都近似16毫秒左右。

这个1毫秒和16毫秒结果，以计算机的运行速度看，差距是惊人的，必须找出其原因。

根据经验，在16毫秒时间内，cpu可以运算的指令数量是相当惊人的，所以可以基本断定这16ms的差距，应当不是cpu在执行指令，另外因为测试过程中gc输出也已经打开，未见gc发生，所以怀疑可能是发生了什么io阻塞，比如文件读写、加载类库、或者什么网络操作等，由于笔者测试的系统的环境比较复杂，其间有用到ehCache，数据库操作等，排查起来非常不容易。

在困扰了好一阵之后，忽然想到可能计时系统有误差，这才翻回来查了下System.currentTimeMillis() 的文档，原来这个方法调用了个native方法，获取的时间精度会依赖于操作系统的实现机制。

奶奶的！既然不准，就看看有没更准的方法，在jdk5源码中，挨着System.currentTimeMillis() 定义就是System.nanoTime() 方法，靠，一下来了个精准1000000倍的取纳秒的方法，不过看jdk文档介绍，这个方法的精度依然依赖操作系统，不过再不准也能达到微秒级的准确度，放心用吧！结果测试结果一下准确了不少，没再发现比较大的跳跃了。

所以这里提醒做非常精确的时间统计的朋友，谨慎使用System.currentTimeMillis() 。

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中计算时间和⽇期的⽅式Java 中计算时间和⽇期的⽅式简要： Java中计算⽇期时间的有 Date类加 SimpleDateFormat类和 System类中的 currentTimeMillis ⽅法，还有专门⽤于⽇期的 Calendar类。

这⾥就介绍如何使⽤这三种⽅式获取当前时间，以及⼀些注意点。

注意：当前计算机时间是跟你的计算机所在时区是有关的所以会有时差GMT时间(格林威治时间)1970年1⽉1号0时0分0秒中国东⼋区相差8⼩时(北京时间)1970年1⽉1号8时0分0秒⼀、Date 类加 SimpleDateFormat 类// 注意使⽤的是 java.util 包下的Date date = new Date();/*常⽤的：yyyy 年（年份四位数）MM ⽉（两位数 12个⽉）dd ⽇两位数不确定）HH 时 24制 / hh 12制mm 分（两位数 60进制）ss 秒（两位数 60进制）SSS 毫秒（1000 毫秒 == 1 秒）*/// java.text 包下的，⽤于⽇期格式化// 其它符号如（- : .）就是连接符，原样输出，也可以是中⽂SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM⽉dd⽇ hh时mm分ss秒");System.out.println(date);// Thu Nov 26 10:43:47 CST 2020System.out.println(sdf1.format(date));// 2020-11-26 10:43:47.999System.out.println(sdf2.format(date));// 2020年11⽉26⽇ 10时51分02秒// String 转 Date 使⽤ SimpleDateFormat 的 parse ⽅法// 格式需要相同，否则会解析异常抛出 ParseExceptiontry {String time = "2008-08-08 08:08:08.888";Date parse = sdf1.parse(time);System.out.println(parse);// Fri Aug 08 08:08:08 CST 2008} catch (ParseException e) {e.printStackTrace();}// 参数是毫秒，从1970年1⽉1⽇00:00:00开始的总毫秒数。

java获取当前日期和时间（各种方法对比）

java获取当前⽇期和时间（各种⽅法对⽐）@⽬录https:///lydms/article/details/103937041⼀、简介使⽤到的时间类有：System.currentTimeMillis()：System.currentTimeMillis()产⽣⼀个当前的毫秒，这个毫秒其实就是⾃1970年1⽉1⽇0时起的毫秒数，类型为long；Date：类Date表⽰特定的瞬间，精确到毫秒。

从 JDK 1.1 开始，应该使⽤Calendar类实现⽇期和时间字段之间转换，使⽤DateFormat类来格式化和解析⽇期字符串。

Date中的相应⽅法已废弃。

Calendar：Calendar类是⼀个抽象类，它为特定瞬间与⼀组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR等之间的转换提供了⼀些⽅法，并为操作⽇历字段（例如获得下星期的⽇期）提供了⼀些⽅法;主要是⽤的是get⽅法：get(int field) 返回给定⽇历字段的值。

其中传⼊的主要参数为：HOUR_OF_DAY ⼀天中某个⼩时；DAY_OF_WEEK ⼀个星期中的某天；DAY_OF_MONTH ⼀个⽉中的某天；DAY_OF_YEAR 当前年中的天数；WEEK_OF_MONTH 当前⽉中的星期数；WEEK_OF_YEAR 当前年中的星期数；⼆、使⽤1、获取当前时间的毫秒值System.currentTimeMillis()long timeNow = System.currentTimeMillis();System.out.println(timeNow);Date（不推荐使⽤）Date date = new Date()getTime();System.out.println(timeNow);2、获取当前的时间System.currentTimeMillis()(yyyy)long time = System.currentTimeMillis();SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd:HH-mm-ss");String day = dateFormat.format(time);System.out.println(day);DateDate date = new Date();SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd:HH-mm-ss");String day = dateFormat.format(date);System.out.println(day);3、获取当前的⽇期(相对于⽉)long timeMillis = System.currentTimeMillis();SimpleDateFormat format = new SimpleDateFormat("dd");String dayOfMonth = format.format(timeMillis);System.out.println(dayOfMonth);CalendarCalendar instance = Calendar.getInstance();int dayOfMonth = instance.get(Calendar.DAY_OF_MONTH);System.out.println(dayOfMonth);4、SimpleDateFormat中格式化字符的含义5、YYYY与yyyy区别⽇期格式化时，yyyy表⽰当天所在的年，⽽⼤写的YYYY代表是week in which year（JDK7之后引⼊的概念），意思是当天所在的周属于的年份，⼀周从周⽇开始，周六结束，只要本周跨年，返回的YYYY就是下⼀年。

JAVA处理期时间常用方法

JAVA处理日期时间常用方法：java .util .Calendar Cale ndar类是一个抽象类，它为特定瞬间与一组诸如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 = newjava.text.SimpleDateFormat("yyyy-MM-dd") 。

System.out.println("Todayis:"+format.format(Calendar.getInstance().getTime()))。

System.out.println("yesterdayis:"+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 Christmas is:"+format.format(date))。

//java月份是从0-11,月份设置时要减1.//Gregoria nCale nda构造方法参数依次为：年，月-1 ，日，时，分，秒.取日期的部分: int year =calendar.get(Calendar.YEAR)。

java获取当前日期和时间的二种方法分享

java获取当前⽇期和时间的⼆种⽅法分享有两种⽅法：⽅法⼀：⽤java.util.Date类来实现，并结合java.text.DateFormat类来实现时间的格式化，看下⾯代码：复制代码代码如下:import java.util.*;import java.text.*;//以下默认时间⽇期显⽰⽅式都是汉语语⾔⽅式//⼀般语⾔就默认汉语就可以了，时间⽇期的格式默认为MEDIUM风格，⽐如：2008-6-16 20:54:53//以下显⽰的⽇期时间都是再Date类的基础上的来的，还可以利⽤Calendar类来实现见类TestDate2.javapublic class TestDate {public static void main(String[] args) {Date now = new Date();Calendar cal = Calendar.getInstance();DateFormat d1 = DateFormat.getDateInstance(); //默认语⾔（汉语）下的默认风格（MEDIUM风格，⽐如：2008-6-16 20:54:53）String str1 = d1.format(now);DateFormat d2 = DateFormat.getDateTimeInstance();String str2 = d2.format(now);DateFormat d3 = DateFormat.getTimeInstance();String str3 = d3.format(now);DateFormat d4 = DateFormat.getInstance(); //使⽤SHORT风格显⽰⽇期和时间String str4 = d4.format(now);DateFormat d5 = DateFormat.getDateTimeInstance(DateFormat.FULL,DateFormat.FULL); //显⽰⽇期，周，时间（精确到秒）String str5 = d5.format(now);DateFormat d6 = DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG); //显⽰⽇期。

JAVA计算日期时间差的几种方法

JAVA计算日期时间差的几种方法在Java中，有几种方法可以计算日期和时间的差异。

下面将介绍一些常用的方法。

1. 使用java.util.Date和java.util.Calendar类：-获取两个日期之间的毫秒差：将两个日期转换为毫秒数，然后相减。

- 获取两个日期之间的天数差：将两个日期转换为Calendar对象，然后计算两个日期之间的天数差。

- 获取两个日期之间的小时差：将两个日期转换为Calendar对象，然后计算两个日期之间的小时差。

示例代码：```javaimport java.util.Date;import java.util.Calendar;public class DateDifferenceExamplepublic static void main(String[] args)//获取当前日期和时间Date currentDate = new Date(;//获取指定日期和时间Calendar calendar = Calendar.getInstance(;calendar.set(2024, Calendar.JANUARY, 1, 0, 0, 0);Date specifiedDate = calendar.getTime(;//计算日期和时间差long millisecondsDiff = specifiedDate.getTime( - currentDate.getTime(;calendar.setTimeInMillis(millisecondsDiff);int daysDiff = calendar.get(Calendar.DAY_OF_YEAR);int hoursDiff = calendar.get(Calendar.HOUR_OF_DAY);//输出结果System.out.println("毫秒差: " + millisecondsDiff);System.out.println("天数差: " + daysDiff);System.out.println("小时差: " + hoursDiff);}```- 获取两个日期之间的天数差：使用Period类的between方法计算两个LocalDate对象之间的天数差。

java中获取日期和时间的方法总结

java中获取⽇期和时间的⽅法总结1、获取当前时间，和某个时间进⾏⽐较。

此时主要拿long型的时间值。

⽅法如下：要使⽤ java.util.Date 。

获取当前时间的代码如下Date date = new Date();date.getTime() ;还有⼀种⽅式，使⽤ System.currentTimeMillis() ;都是得到⼀个当前的时间的long型的时间的毫秒值，这个值实际上是当前时间值与1970年⼀⽉⼀号零时零分零秒相差的毫秒数⼀、获取当前时间, 格式为: yyyy-mm-dd hh-mm-ssDateFormat.getDateTimeInstance(2, 2, Locale.CHINESE).format(new java.util.Date());⼆、获取当前时间, 格式为: yyyy年mm⽉dd⽇上午/下午hh时mm分ss秒1 DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, Locale.CHINESE).format(new java.util.Date());三、获取当前时间(精确到毫秒), 格式为: yyyy-mm-dd hh:mm:ss.nnn1new java.sql.Timestamp(System.currentTimeMillis()).toString();⼀. 获取当前系统时间和⽇期并格式化输出:1import java.util.Date;2import java.text.SimpleDateFormat;3public class NowString {4public static void main(String[] args) {5 SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置⽇期格式6 System.out.println(df.format(new Date()));// new Date()为获取当前系统时间7 }8 }⼆. 在数据库⾥的⽇期只以年-⽉-⽇的⽅式输出，可以⽤下⾯两种⽅法：1、⽤convert()转化函数：String sqlst = "select convert(varchar(10),bookDate,126) as convertBookDate from roomBook where bookDate between '2007-4-10' and '2007-4-25'" System.out.println(rs.getString("convertBookDate"));2、利⽤SimpleDateFormat类：先要输⼊两个java包：import java.util.Date;import java.text.SimpleDateFormat;然后：定义⽇期格式：SimpleDateFormat sdf = new SimpleDateFormat(yy-MM-dd);sql语句为：String sqlStr = "select bookDate from roomBook where bookDate between '2007-4-10' and '2007-4-25'";输出：System.out.println(df.format(rs.getDate("bookDate")));3、java中获取当前⽇期和时间的⽅法1)如何取得年⽉⽇、⼩时分秒？2)如何取得从1970 年到现在的毫秒数？3)如何取得某个⽇期是当⽉的最后⼀天？4)如何格式化⽇期？1import java.sql.Date;2import java.text.SimpleDateFormat;3import java.util.Calendar;45public class Demo12 {67/**8 * @param args9*/10public static void main(String[] args) {11// TODO Auto-generated method stub12 Calendar c = Calendar.getInstance();13 System.out.println("年：" + c.get(Calendar.YEAR));14 System.out.println("⽉：" + (c.get(Calendar.MONTH) + 1));15 System.out.println("⽇：" + c.get(Calendar.DAY_OF_MONTH));16 System.out.println("24时制⼩时：" + c.get(Calendar.HOUR_OF_DAY));17 System.out.println("12时制：" + c.get(Calendar.HOUR));18 System.out.println("分：" + c.get(Calendar.MINUTE));19 System.out.println("秒：" + c.get(Calendar.SECOND));20 System.out.println("今天是⼀年中的第：" + c.get(Calendar.DAY_OF_YEAR) + "天");21//-------毫秒数2223long currentSec = System.currentTimeMillis();24 System.out.println("毫秒数为：" + currentSec);2526//------⽇期最后⼀天2728int maxDay = c.getActualMaximum(Calendar.DAY_OF_MONTH);29 System.out.println("当前⽇期最后⼀天：" + maxDay);3031//-------格式化⽇期3233 String format = "yyyy年MM⽉dd⽇ HH:mm:ss";34 SimpleDateFormat SDF = new SimpleDateFormat(format);35 String timer = SDF.format(new Date(currentSec));36 System.out.println("格式化⽇期后：" + timer);3738 }3940 }⼆1import java.util.Date;2import java.util.Calendar;3import java.text.SimpleDateFormat;4public class TestDate{5public static void main(String[] args){6 Date now = new Date();7 SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");//可以⽅便地修改⽇期格式89 String hehe = dateFormat.format( now );10 System.out.println(hehe);11 Calendar c = Calendar.getInstance();//可以对每个时间域单独修改14int year = c.get(Calendar.YEAR);15int month = c.get(Calendar.MONTH);16int date = c.get(Calendar.DATE);17int hour = c.get(Calendar.HOUR_OF_DAY);18int minute = c.get(Calendar.MINUTE);19int second = c.get(Calendar.SECOND);20 System.out.println(year + "/" + month + "/" + date + " " +hour + ":" +minute + ":" + second);21 }22 }23有时候要把String类型的时间转换为Date类型，通过以下的⽅式，就可以将你刚得到的时间字符串转换为Date类型了。

java计算当前时间距离指定时间秒数的公式

一、引言在日常的开发工作中，我们经常需要计算当前时间距离指定时间的秒数。

比如在某些业务场景中，我们需要计算当前时间距离某个特定时间点的倒计时秒数，或者需要计算两个时间点之间的时间差。

由于Java是一种非常常用的编程语言，因此了解如何在Java中计算当前时间距离指定时间的秒数是非常重要的。

二、获取当前时间在Java中，我们可以使用`java.util.Date`类或者`java.time.LocalDateTime`类来获取当前时间。

以下是两种方法的示例代码：1. 使用`java.util.Date`类```javaimport java.util.Date;public class Main {public static void main(String[] args) {Date currentTime = new Date();System.out.println("当前时间：" + currentTime);}}```2. 使用`java.time.LocalDateTime`类```javaimport java.time.LocalDateTime;public class Main {public static void main(String[] args) {LocalDateTime currentTime = LocalDateTime.now();System.out.println("当前时间：" + currentTime);}}```三、计算时间差一旦我们获取了当前时间和指定时间，我们需要计算它们之间的时间差，即秒数。

在Java中，我们可以使用`java.time.Duration`类来计算时间差。

以下是一个示例代码：```javaimport java.time.Duration;import java.time.LocalDateTime;public class Main {public static void main(String[] args) {LocalDateTime currentTime = LocalDateTime.now();LocalDateTime specifiedTime = LocalDateTime.of(2022, 1, 1, 0, 0, 0);Duration duration = Duration.between(currentTime, specifiedTime);long seconds = duration.getSeconds();System.out.println("当前时间距离指定时间的秒数：" + seconds);}}```在上面的示例代码中，我们首先获取了当前时间和指定时间，然后使用`Duration.between`方法计算它们之间的时间差，并将结果转换为秒数。

Java时间操作常用api

Java时间操作常⽤api- 如何取得年⽉⽇、⼩时分钟秒？- 如何取得从1970年1⽉1⽇0时0分0秒到现在的毫秒数？- 如何取得某⽉的最后⼀天？- 如何格式化⽇期？答：问题1：创建java.util.Calendar 实例，调⽤其get()⽅法传⼊不同的参数即可获得参数所对应的值。

Java 8中可以使⽤java.time.LocalDateTimel来获取，代码如下所⽰。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20public class DateTimeTest {public static void main(String[] args) {Calendar cal = Calendar.getInstance();System.out.println(cal.get(Calendar.YEAR));System.out.println(cal.get(Calendar.MONTH)); // 0 - 11 System.out.println(cal.get(Calendar.DATE));System.out.println(cal.get(Calendar.HOUR_OF_DAY)); System.out.println(cal.get(Calendar.MINUTE));System.out.println(cal.get(Calendar.SECOND));// Java 8LocalDateTime dt = LocalDateTime.now();System.out.println(dt.getYear());System.out.println(dt.getMonthValue()); // 1 - 12System.out.println(dt.getDayOfMonth());System.out.println(dt.getHour());System.out.println(dt.getMinute());System.out.println(dt.getSecond());}}问题2：以下⽅法均可获得该毫秒数。

Java中时间格式处理，指定N天小时等之后的时间

Java中时间格式处理，指定N天⼩时等之后的时间1）根据当前时间，获取具体的时刻的时间N天前M⼩时之前可⽤new Date().getTime() - 24 * 60 * 60 * 1000*N【N天之前】的⽅法来获取处理时间之后的具体的值，最终转化为想要的时间格式import java.text.SimpleDateFormat;import java.util.Date;public class getTime {public static void main(String[] args) {SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");Date time = new Date(new Date().getTime() - 24 * 60 * 60 * 1000);System.out.println(sd.format(time));System.out.println(sd.format(new Date()));//想获得N天之前或M天之后的时间int NDay = 5;int MDay = -10; //之后就传负数Date timeN = new Date(new Date().getTime() - 24 * 60 * 60 * 1000 * NDay);Date timeM = new Date(new Date().getTime() - 24 * 60 * 60 * 1000 * MDay);System.out.println(sd.format(timeN));System.out.println(sd.format(timeM));//想获得N⼩时之前或M⼩时之后的时间int NHour = 5;int MHour = -10; //之后就传负数Date timeNHour = new Date(new Date().getTime() - 60 * 60 * 1000 * NHour);Date timeMHour = new Date(new Date().getTime() - 60 * 60 * 1000 * MHour);System.out.println(sd.format(timeNHour));System.out.println(sd.format(timeMHour));//想获得N分钟之前或M分钟之后的时间int NMinute = 5;int MMinute = -10; //之后就传负数Date timeNMinute = new Date(new Date().getTime() - 60 * 1000 * NMinute);Date timeMMiute = new Date(new Date().getTime() - 60 * 1000 * MMinute);System.out.println(sd.format(timeNMinute));System.out.println(sd.format(timeMMiute));//想获得N秒之前或M秒之后的时间int NSecond = 5;int MSecond = -10; //之后就传负数Date timeNSecond = new Date(new Date().getTime() - 1000 * NSecond);Date timeMSecond = new Date(new Date().getTime() - 1000 * MSecond);System.out.println(sd.format(timeNSecond));System.out.println(sd.format(timeMSecond));long Ntime = getDetailtime(3, 20, 1, 1);System.out.println(sd.format(Ntime));System.out.println(Ntime);Date Ntime2 = getDetailDate(3, 20, 1, 1);System.out.println(sd.format(Ntime2));System.out.println(Ntime2);}public static Date getDetailDate(int Day, int Hour, int Minute, int Second) {Date timeN = new Date(new Date().getTime() - Day * 24 * 60 * 60 * 1000 - Hour * 60 * 60 * 1000 - Minute * 60 * 1000 - Second * 1000);return timeN;}public static long getDetailtime(int Day, int Hour, int Minute, int Second) {long timeN = new Date().getTime() - Day * 24 * 60 * 60 * 1000 - Hour * 60 * 60 * 1000 - Minute * 60 * 1000 - Second * 1000;return timeN;}} 那么想要更加具体的时间，⽐如让⽤户输⼊具体的天，时，分钟，秒等，可以获取更加精准的想要的时刻public static Date getDetailDate(int Day, int Hour, int Minute, int Second) {Date timeN = new Date(new Date().getTime() - Day * 24 * 60 * 60 * 1000 - Hour * 60 * 60 * 1000 - Minute * 60 * 1000 - Second * 1000); return timeN;}public static long getDetailtime(int Day, int Hour, int Minute, int Second) {long timeN = new Date().getTime() - Day * 24 * 60 * 60 * 1000 - Hour * 60 * 60 * 1000 - Minute * 60 * 1000 - Second * 1000;return timeN;}2）根据java.util.Calendar中的操作ca.add(Calendar.DATE, -N);【减去N天】import java.text.SimpleDateFormat;import java.util.Calendar;import java.util.Date;public class getTime2 {public static void main(String[] args) {SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");int N=2;Calendar ca = Calendar.getInstance();//得到⼀个Calendar的实例ca.setTime(new Date()); //设置时间为当前时间ca.add(Calendar.DATE, -N);long timeDay= ca.getTime().getTime();Calendar ca2 = Calendar.getInstance();//得到⼀个Calendar的实例ca2.setTime(new Date()); //设置时间为当前时间ca2.add(Calendar.HOUR, -N);long timeDay2= ca2.getTime().getTime();Calendar ca3 = Calendar.getInstance();//得到⼀个Calendar的实例ca3.setTime(new Date()); //设置时间为当前时间ca3.add(Calendar.MINUTE, -N);long timeDay3= ca3.getTime().getTime();Calendar ca4 = Calendar.getInstance();//得到⼀个Calendar的实例ca4.setTime(new Date()); //设置时间为当前时间ca4.add(Calendar.SECOND, -N);long timeDay4= ca4.getTime().getTime();System.out.println(sd.format(timeDay));System.out.println(sd.format(timeDay2));System.out.println(sd.format(timeDay3));System.out.println(sd.format(timeDay4));Calendar ca5 = Calendar.getInstance();//得到⼀个Calendar的实例ca5.setTime(new Date()); //设置时间为当前时间ca5.add(Calendar.MONTH, -N);long timeDay5= ca5.getTime().getTime();System.out.println(sd.format(timeDay5));Calendar ca6 = Calendar.getInstance();//得到⼀个Calendar的实例ca6.setTime(new Date()); //设置时间为当前时间ca6.add(Calendar.YEAR, -N);long timeDay6= ca6.getTime().getTime();System.out.println(sd.format(timeDay6));}}3）Java中Date 有⼀些不建议⽤的⽅法4）运⽤已有的⼀些jar依赖，⽐如ng3.time.DateUtils;其中已经集成了的apiimport ng3.time.DateUtils;import java.text.SimpleDateFormat;import java.util.Date;public class TestLongtime {public static void main(String[] args) {SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");System.out.println(sd.format(new Date()));System.out.println(sd.format(new Date().getTime()));Date now = new Date();Date year = DateUtils.addYears(now, -2);Date day = DateUtils.addDays(now, -2);Date hour = DateUtils.addHours(now, -2);Date minute = DateUtils.addMinutes(now, -2);Date second = DateUtils.addSeconds(now, -2);//long bb = Long.parseLong(startDate.toString());System.out.println(sd.format(year));System.out.println(sd.format(day));System.out.println(sd.format(hour));System.out.println(sd.format(minute));System.out.println(sd.format(second));}}5）常⽤的String类型转换到long类型long bb = Long.parseLong(startDate.toString());6）Java中long类型的10位和13位的时间戳，转换为可供查看的时间格式如果接⼝⽂档中规定的是String类型，要注意⼀定不能含有l，只能含有数字public static String timestamp2Date(String str_num) {SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");if (str_num.length() == 13) {String date = sdf.format(new Date(toLong(str_num)));System.out.println("将13位时间戳:" + str_num + "转化为字符串:" + date);return date;} else {String date = sdf.format(new Date(toLong(str_num) * 1000));System.out.println("将10位时间戳:" + str_num + "转化为字符串:" + date);return date;}}public static long toLong(String obj) { return Long.parseLong(obj);}@Testpublic void Te(){String aaa = "1566802997242"; String bbb = "1566801239";System.out.println(aaa.length()); System.out.println(bbb.length()); timestamp2Date(aaa);timestamp2Date(bbb);}。

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)首先，我应该提醒一下，每一个构造函数需要时间信息中的日期信息(年，月，日)。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

] java中获取比毫秒更为精确的时间(2012-07-03 11:54:33)转载▼分类：实践经验标签：杂谈from: /paul_lh/article/details/6419982关键词：java 毫秒微秒纳秒System.currentTimeMillis() 误差在对新写的超快xml解析器和xpath引擎进行效率测试时，为获取执行时间，开始也没多想就用了System.currentTimeMillis() 来做的。

这个1毫秒和16毫秒结果，以计算机的运行速度看，差距是惊人的，必须找出其原因。

所以这里提醒做非常精确的时间统计的朋友，谨慎使用System.currentTimeMillis() 。

虽然用取纳秒的方法解决了我的问题，但对于为何使用System.currentTimeMillis() 会造成那么大的跳跃，一直无解，有点郁闷。

幸运的是今天恰巧看到一个网友做的测试很有意思，用事实数据证明了这个跳跃的存在，分享给感兴趣的同学！（原文链接：/elky1982/archive/2009/10/16/4677365.aspx）以下内容为转帖：在Java中可以通过System.currentTimeMillis()或者System.nanoTime() (JDK>=5.0) 方法获得当前的时间的精确值。

但是通过阅读Javadoc，我们发现这两个方法并不一定保证得到你所期望的精度。

先来看System.currentTimeMillis()：Returns the current time in milliseconds. Note that while the unit of time of the return value is a millisecond, the granularity of the value depends on the underlying operating system and may be larger. For example, many operating systems measure time in units of tens of milliseconds.诚如上面所说返回值的粒度依赖于底层操作系统，那么它在不同的平台上到底能提供是么样的精度，是否像函数名所写的那样真正精确到1毫秒呢？看下面一段测试程序：public class ClockAccuracyTest {public static void main(String args[]) {SimpleDateFormat formatter = new SimpleDateFormat("dd-MMM-yyyy HH:mm:ss:SSS");int size = 4000000;// create an array to hold millisecond times// and loop to capture themlong times[] = new long[size];for (int i = 0; i < size; i++) {times[i] = System.currentTimeMillis();}// now display the unique timeslong time = times[0];long previousTime = times[0];long count = 0;Set<Long> deltas = new HashSet<Long>();long delta = 0;long minDelta = Long.MAX_VALUE;long maxDelta = Long.MIN_VALUE;for (int i = 0; i < size; i++) {if (times[i] > time) {delta = time - previousTime;deltas.add(delta);if (delta > 0 && delta < minDelta) {minDelta = delta;} else if (delta > maxDelta) {maxDelta = delta;}System.out.print("raw=");System.out.print(time);System.out.print(" | formatted=");System.out.print(formatter.format(new Date(time)));System.out.print(" | frequency=");System.out.print(count);System.out.print(" | delta=");System.out.print(delta);System.out.println("ms");previousTime = time;time = times[i];count = 0;} else {count++;}}System.out.println("");System.out.println("Minimum delta : " + minDelta + "ms");System.out.println("Maximum delta : " + maxDelta + "ms");}}这段程序循环调用System.currentTimeMillis()方法，记录并显示结果，在我机器(Windows XP SP3)上运行输出如下：raw=1255659457187 | formatted=16-十月-2009 10:17:37:187 | frequency=147250 |delta=0msraw=1255659457203 | formatted=16-十月-2009 10:17:37:203 | frequency=447674 |delta=16msraw=1255659457218 | formatted=16-十月-2009 10:17:37:218 | frequency=436583 |delta=15msraw=1255659457234 | formatted=16-十月-2009 10:17:37:234 | frequency=439379 |delta=16msraw=1255659457250 | formatted=16-十月-2009 10:17:37:250 | frequency=426547 |delta=16msraw=1255659457265 | formatted=16-十月-2009 10:17:37:265 | frequency=447048 |delta=15msraw=1255659457281 | formatted=16-十月-2009 10:17:37:281 | frequency=459522 | delta=16msraw=1255659457296 | formatted=16-十月-2009 10:17:37:296 | frequency=414816 | delta=15msraw=1255659457312 | formatted=16-十月-2009 10:17:37:312 | frequency=458826 | delta=16msMinimum delta : 15msMaximum delta : 16ms输出的四列从左到右分别是原始的毫秒值、格式化的时间、每个值循环的次数、与上一个不同值的差。

可以看到在Windows上System.currentTimeMillis()方法并不能提供1ms的计时粒度，它的粒度为15~16ms，从网上的其它文章来看，这个结果基本上是一致的，这也验证了Javadoc上所写的“ the granularity of the value depends on the underlying operating system and may be larger ”。

在其他操作系统，如Linux、Solaris上，我没有进行测试，但从网上的一些测试结果看，currentTimeMillis方法在某些操作系统能够提供精确的1毫秒计时粒度。

这是不是意味着Java在Windows上无法进行精确的毫秒计时了呢？当然不是，一种解决方案是采用JNI调用，利用Windows系统提供的函数计时；还有一个更简便的办法，就是使用JDK5.0加入的System.nanoTime()方法。

Javadoc对该方法的描述如下：Returns the current value of the most precise available system timer, in nanoseconds.This method can only be used to measure elapsed time and is not related to any other notion of system or wall-clock time. The value returned represents nanoseconds since some fixed but arbitrary time (perhaps in the future, so values may be negative). This method provides nanosecond precision, but not necessarily nanosecond accuracy. No guarantees are made about how frequently values change. Differences in successive calls that span greater than approximately 292 years (263 nanoseconds) will not accurately compute elapsed time due to numerical overflow.它返回系统能够提供的最为精确的计时，以纳秒(10亿分之一秒)为单位，但并不保证纳秒级精度。