------2019.08.06补充
日期年与日的加减运算。
给定一个开始日期，对其进行加年，加月，加天运算
如下给起始日期和给定月份，计算结束日期
/**
* 给起始日期和给定月份，计算结束日期工具
* 开始日期格式为：yyyy-MM-dd
* */
public static String getEndDateBymonths(String startDateStr, int months){
//分隔日期为字符串数组，1为年，2为月，3为日
String dataStr[] = startDateStr.split("-");
//年份,开始日期的月份加上当前月份。除以12，即增加年数。
int year = (Integer.parseInt(dataStr[1]) + months)/12;
//月份
int mon = (Integer.parseInt(dataStr[1]) + months)%12; //格式化月份。
String a = "";
if(mon<10){
if(mon<1){
a = "12";
}else{
a = "0"+mon;
}
}else {
a = mon+"";
}
dataStr[0]=String.valueOf(Integer.parseInt(dataStr[0]) + year);
dataStr[1]=a;
String newdata ="";
newdata = dataStr[0]+"-"+dataStr[1]+"-"+dataStr[2];
return newdata;
}
自己编写计算方法需要很长代码。而如果借助java.util.Calendar类来进行日期计算，能够很方便计算出年月日的加减
SimpleDateFormat sj = new SimpleDateFormat("yyyy-MM-dd");
String newdata ="2018-01-01";
Date d;
try {
d = sj.parse(newdata);
Calendar calendar = Calendar.getInstance();
calendar.setTime(d);
calendar.add(Calendar.MONTH, 3);
newdata = sj.format(calendar.getTime());
} catch (ParseException e) {
e.printStackTrace();
}
System.out.println(newdata);
上面加月份只需要几行代码，而不需要我们考虑内部细节
如果要加3年
calendar.add(Calendar.YEAR, 3);
减三年用calendar.add(Calendar.YEAR, -3);
Calendar的属性字段有：YEAR年的计算，MONTH月的计算，DATE日的计算
借助工具类可以更加灵活方便
两个日期之间相减得到的天数
(int) ((dateEnd.getTime() - dateStart.getTime()) / 1000 / 60 / 60 / 24)
实现思路是通过java.util.Date类的getTime()方法获得日期的毫秒数，
然后相减dateEnd.getTime() - dateStart.getTime()，得到毫秒数的差，除以1000，得到秒数的差；再除以60，得到分钟数的差；再除以60，得到小时数的差；再除以24小时，得到天数的差。
————————————————
版权声明：本文为CSDN博主「wpydaguan」的原创文章，遵循CC 4.0 by-sa版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/wpydaguan/article/details/46235349
1、获得时间戳
为了统一其他语言的如php和unix系统获取的时间戳是10位长度的，精确到秒。
java时间戳长度是13位，精确到毫秒 我们获取时间戳需要相应处理。
//获取当前时间戳，除以1000，获取到长度为10位的，精确到秒
public static long now() {
return System.currentTimeMillis() / 1000;
}
2、时间戳转化为固定模式的日期yyyy-MM-dd HH:mm:ss
两种时间戳转换为日期的方法，发现testTime方法比较快。
testTime2将long转换为字符串加0后，再转为long，需要时间比较久。
public static String testTime(String pattern, long timestamp) {
SimpleDateFormat format = new SimpleDateFormat(pattern, Locale.SIMPLIFIED_CHINESE);
return format.format(timestamp * 1000);
}
public static String testTime2(String pattern, long timestamp) {
SimpleDateFormat format = new SimpleDateFormat(pattern, Locale.SIMPLIFIED_CHINESE);
return format.format(Long.parseLong(String.valueOf(timestamp) + "000"));
}
3日期转换为时间戳
先将日期字符串转为Date对象，再用Date.getTime()获取时间戳
public static String datePattern = "yyyy-MM-dd";
public static String timeStampPattern = "yyyy-MM-dd HH:mm:ss";
public static Date toDate(String dateStr) {
if (StrKit.isBlank(dateStr)) {
return null;
} dateStr = dateStr.trim();
int length = dateStr.length();
try {
if (length == timeStampPattern.length()) {
SimpleDateFormat sdf = new SimpleDateFormat(timeStampPattern);
try {
return sdf.parse(dateStr);
} catch (ParseException e) {
dateStr = dateStr.replace(".", "-");
dateStr = dateStr.replace("/", "-");
return sdf.parse(dateStr);
}
} else if (length == datePattern.length()) {
SimpleDateFormat sdfDate = new SimpleDateFormat(datePattern);
try {
return sdfDate.parse(dateStr);
} catch (ParseException e) {
dateStr = dateStr.replace(".", "-");
dateStr = dateStr.replace("/", "-");
return sdfDate.parse(dateStr);
}
} else {
throw new IllegalArgumentException("The date format is not supported for the time being");
}
} catch (ParseException e) {
throw new IllegalArgumentException("The date format is not supported for the time being");
}
}
测试代码如下
Date obtain = toDate("2017-12-10");
long ss = obtain.getTime();
String dateStr = timestamp2DateTime("yyyy-MM-dd HH:mm:ss", ss);
System.out.println(dateStr);
结果2017-12-10 00:00:00
下面是废话
前端用js的Date对象的Date.getTime()方法获取到的时间戳是13位长度的，精确到毫秒，一般需要进行转换成精确度到秒。即除以1000
#时间戳转日期
一般时间戳都是精确到毫秒
默认的时间戳转日期的方法。
这个方法是调用的SimpleDateFormat只有一个参数的构造方法获得格式转换对象
这个方法会让我们对时间格式时区掌控，当系统所在时区发生变化时，日期格式也会发生变化
public static String timestamp2DateTime(String pattern, long timestamp) {
SimpleDateFormat format = new SimpleDateFormat(pattern);
return format.format(timestamp);
}
上面的SimpleDateFormat(pattern)
默认会指定当前运行环境所在时区为构造方法，这种不确定性的默认应该需要避免
public SimpleDateFormat(String pattern)
{
this(pattern, Locale.getDefault(Locale.Category.FORMAT));
}
我们自己指定需要转换的时区
获取到Locale，即指定国家的时间，这里是获得简体中文，北京时间也就是东八区的locale对象
Locale simpleChinese = new Locale("zh","CN");
Locale.SIMPLIFIED_CHINESE
/**
* 时间戳转化为北京时间日期格式
* @param pattern
* 如：yyyy-MM-dd HH:mm:ss 获取时间格式为: 年-月-日 时:分:秒<br>
* pattern模式匹配语法：
G 年代标志符<br>
y 年<br>
M 月<br>
d 日<br>
h 时 在上午或下午 (1~12)<br>
H 时 在一天中 (0~23)<br>
m 分<br>
s 秒<br>
S 毫秒<br>
E 星期<br>
D 一年中的第几天<br>
F 一月中第几个星期几<br>
w 一年中第几个星期<br>
W 一月中第几个星期<br>
a 上午 / 下午 标记符<br>
k 时 在一天中 (1~24)<br>
K 时 在上午或下午 (0~11)<br>
z 时区<br>
* @param timestamp
* 时间戳
* @return
*/
public static String timestamp2DateTime(String pattern, long timestamp) {
//使用简体中文所在的时区
SimpleDateFormat format = new SimpleDateFormat(pattern,Locale.SIMPLIFIED_CHINESE);
return format.format(timestamp);
}
时间更精确的值
1秒 = 1 X 10E15(次方)飞秒 = 1 X 10E12 皮秒 = 1 X 10E9 纳秒 = 1 X 10E6 微妙 = 1 X 10E3 毫秒
1秒 = 1000000000000000飞秒 = 1000000000000皮秒 = 1000000000纳秒 = 1000000微秒 = 1000毫秒
1秒 = 1000000000000皮秒 = 1000000000纳秒 = 1000000微秒 = 1000毫秒
1秒 = 1000000000纳秒 = 1000000微秒 = 1000毫秒
1秒 = 1000000微秒 = 1000毫秒
1秒 = 1000毫秒
#纳秒
1秒等于10的9次方纳秒
这个纳秒只能用来精确统计程序运行的时间，比如计算一个程序运行的时间长短，需要一定的准确度。用currentTimeMillis(）只能精确到毫秒
System.currentTimeMillis()起始时间是基于1970.1 10:00:00这个
前段时间项目中需要 统计接口连接时间,考虑到连接时间一般都是零点几毫秒级别的,为了拿到更精确地数值,没有使用System.currentTimeMillis(),而是贸然地使用System.nanoTime()来统计时间,后来分析服务器上的数据,发现 竟然有10-15%的数据数值竟然超过了 10的13次方。
原因:
System.currentTimeMillis() 起始时间是基于 1970.1.1 0:00:00 这个确定的时间的,而System.nanoTime()是基于cpu核心的时钟周期来计时,它的开始时间是不确定的。(有篇文章说是根据cpu核心的启动时间开始计算的)
但是在多核处理器上,由于每个核心的开始时间不确定,但是在多核处理器上,
long start = System.nanoTime();String ip = Utilities.getIpByUrl(url);long cost = System.nanoTime() - start;
这段代码有可能会运行在两个不同的cpu核心上,从而导致得到的结果完全不符逻辑。
这是测试纳秒的时间间隔的测试方法
60万次数据进行测试，600万数据太大，文本文件打不开，看来要重新安装nodepad++才好。
File tmpFile = new File("D:/testNanoTime.txt");
FileWriter write = null;
try {
write = new FileWriter(tmpFile);
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
int size = 600000;
long[] timeStamp = new long[size];
for (int i = 0; i < size; i++) {
timeStamp[i] = System.nanoTime();
}
long increase = 0l;
for (int i = 0; i < size - 1; i++) {
increase = timeStamp[i + 1] - timeStamp[i];
if (increase > 0) {
// System.out.println("第" + i+1 + "个:"+timeStamp[i + 1]+"第" + i + "个:"+timeStamp[i]+"差值"+increase);
try {
write.write("第" + i+1 + "个:"+timeStamp[i + 1]+"第" + i + "个:"+timeStamp[i]+"差值"+increase+"\n");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
increase = 0;
}
try {
write.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("操作完成");