java date总结

Java 8 中 Date与LocalDateTime、LocalDate、LocalTime互转

 

Java 8中 java.util.Date 类新增了两个方法，分别是from(Instant instant)和toInstant()方法

// Obtains an instance of Date from an Instant object.
public static Date from(Instant instant) {
    try {
        return new Date(instant.toEpochMilli());
    } catch (ArithmeticException ex) {
        throw new IllegalArgumentException(ex);
    }
}

// Converts this Date object to an Instant.
public Instant toInstant() {
    return Instant.ofEpochMilli(getTime());
}

这两个方法使我们可以方便的实现将旧的日期类转换为新的日期类，具体思路都是通过Instant当中介，然后通过Instant来创建LocalDateTime（这个类可以很容易获取LocalDate和LocalTime），新的日期类转旧的也是如此，将新的先转成LocalDateTime，然后获取Instant，接着转成Date，具体实现细节如下：

// 01. java.util.Date --> java.time.LocalDateTime
public void UDateToLocalDateTime() {
    java.util.Date date = new java.util.Date();
    Instant instant = date.toInstant();
    ZoneId zone = ZoneId.systemDefault();
    LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, zone);
}

// 02. java.util.Date --> java.time.LocalDate
public void UDateToLocalDate() {
    java.util.Date date = new java.util.Date();
    Instant instant = date.toInstant();
    ZoneId zone = ZoneId.systemDefault();
    LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, zone);
    LocalDate localDate = localDateTime.toLocalDate();
}

// 03. java.util.Date --> java.time.LocalTime
public void UDateToLocalTime() {
    java.util.Date date = new java.util.Date();
    Instant instant = date.toInstant();
    ZoneId zone = ZoneId.systemDefault();
    LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, zone);
    LocalTime localTime = localDateTime.toLocalTime();
}

// 04. java.time.LocalDateTime --> java.util.Date
public void LocalDateTimeToUdate() {
    LocalDateTime localDateTime = LocalDateTime.now();
    ZoneId zone = ZoneId.systemDefault();
    Instant instant = localDateTime.atZone(zone).toInstant();
    java.util.Date date = Date.from(instant);
}

// 05. java.time.LocalDate --> java.util.Date
public void LocalDateToUdate() {
    LocalDate localDate = LocalDate.now();
    ZoneId zone = ZoneId.systemDefault();
    Instant instant = localDate.atStartOfDay().atZone(zone).toInstant();
    java.util.Date date = Date.from(instant);
}

// 06. java.time.LocalTime --> java.util.Date
public void LocalTimeToUdate() {
    LocalTime localTime = LocalTime.now();
    LocalDate localDate = LocalDate.now();
    LocalDateTime localDateTime = LocalDateTime.of(localDate, localTime);
    ZoneId zone = ZoneId.systemDefault();
    Instant instant = localDateTime.atZone(zone).toInstant();
    java.util.Date date = Date.from(instant);
}

Date类学习总结　

1.计算某一月份的最大天数

Calendar time=Calendar.getInstance();
time.clear();
time.set(Calendar.YEAR,year); //year 为 int 
time.set(Calendar.MONTH,i-1);//注意,Calendar对象默认一月为0           
int day=time.getActualMaximum(Calendar.DAY_OF_MONTH);//本月份的天数
注：在使用set方法之前，必须先clear一下，否则很多信息会继承自系统当前时间

2.Calendar和Date的转化

(1) Calendar转化为Date
Calendar cal=Calendar.getInstance();
Date date=cal.getTime();

(2) Date转化为Calendar
Date date=new Date();
Calendar cal=Calendar.getInstance();
cal.setTime(date);

3.把字符串转化为java.util.Date
方法一：
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
java.util.Date dt=sdf.parse("2005-2-19");
System.out.print(sdf.format(dt));    //输出结果是：2005-2-19

方法二：
java.util.Date dt=null;
DateFormat df=DateFormat.getDateInstance();
dt=df.parse("2005-12-19");
System.out.println(dt);              //输出结果为：Mon Dec 19 00:00:00 CST 2005
System.out.println(df.format(dt)); //输出结果为：2005-2-19

4.把字符串转化为java.sql.Date
字符串必须是"yyyy-mm-dd"格式，否则会抛出IllegalArgumentException异常
java.sql.Date sdt=java.sql.Date.valueOf("2005-9-6");
System.out.println(sdt);          //输出结果为：2005-9-6

5.格式化输出日期时间 （这个用的比较多）

Date date=new Date();
SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
String time=df.format(date);
System.out.println(time);

需要注意的一点：SimpleDateFormat类格式化一个字符串时，可根据需要调用 format() 或 parse() 函数；只不过format()返回String类型，parse()返回java.util.Date类型

6.计算一年中的第几星期

(1)计算某一天是一年中的第几星期
Calendar cal=Calendar.getInstance();
cal.set(Calendar.YEAR, 2006);
cal.set(Calendar.MONTH, 8);
cal.set(Calendar.DAY_OF_MONTH, 3);
int weekno=cal.get(Calendar.WEEK_OF_YEAR);

(2)计算一年中的第几星期是几号
SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd");
Calendar cal=Calendar.getInstance();
cal.set(Calendar.YEAR, 2006);
cal.set(Calendar.WEEK_OF_YEAR, 1);
cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
System.out.println(df.format(cal.getTime()));
输出:
2006-01-02

7.add()和roll()的用法(不太常用)

(1)add()方法
SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd");
Calendar cal=Calendar.getInstance();
cal.set(Calendar.YEAR, 2006);
cal.set(Calendar.MONTH, 8);
cal.set(Calendar.DAY_OF_MONTH, 3);
cal.add(Calendar.DATE, -4);
Date date=cal.getTime();
System.out.println(df.format(date));
cal.add(Calendar.DATE, 4);
date=cal.getTime();
System.out.println(df.format(date));
输出：
    2006-08-30
    2006-09-03
(2)roll方法
cal.set(Calendar.YEAR, 2006);
cal.set(Calendar.MONTH, 8);
cal.set(Calendar.DAY_OF_MONTH, 3);
cal.roll(Calendar.DATE, -4);
date=cal.getTime();
System.out.println(df.format(date));
cal.roll(Calendar.DATE, 4);
date=cal.getTime();
System.out.println(df.format(date));
输出：
    2006-09-29
    2006-09-03
可见，roll()方法在本月内循环，一般使用add()方法；

8.计算两个任意时间中间的间隔天数（这个比较常用）
(1)传进Calendar对象
    public int getIntervalDays(Calendar startday,Calendar endday){       
        if(startday.after(endday)){
            Calendar cal=startday;
            startday=endday;
            endday=cal;
        }    
        long sl=startday.getTimeInMillis();
        long el=endday.getTimeInMillis();
       
        long ei=el-sl;           
        return (int)(ei/(1000*60*60*24));
    }
(2)传进Date对象

public int getIntervalDays(Date startday,Date endday){        
        if(startday.after(endday)){
            Date cal=startday;
            startday=endday;
            endday=cal;
        }        
        long sl=startday.getTime();
        long el=endday.getTime();       
        long ei=el-sl;           
        return (int)(ei/(1000*60*60*24));
    }
(3)改进精确计算相隔天数的方法
    public int getDaysBetween (Calendar d1, Calendar d2){
        if (d1.after(d2)){ 
            java.util.Calendar swap = d1;
            d1 = d2;
            d2 = swap;
        }
        int days = d2.get(Calendar.DAY_OF_YEAR) - d1.get(Calendar.DAY_OF_YEAR);
        int y2 = d2.get(Calendar.YEAR);
        if (d1.get(Calendar.YEAR) != y2){
            d1 = (Calendar) d1.clone();
            do{
                days += d1.getActualMaximum(Calendar.DAY_F_YEAR);//得到当年的实际天数
                d1.add(Calendar.YEAR, 1);
            } while (d1.get(Calendar.YEAR) != y2);
        }
        return days;
    }
注意：通过上面的方法可以衍生出求任何时间，如要查出邮箱三周之内收到的邮件（得到当前系统时间－再得到三周前时间）用收件的时间去匹配 最好装化成 long去比较
如：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);
   3周前的日期
   Calendar cal3 = Calendar.getInstance();
cal3.add(cal3.DATE, -21);//取3周前的日期
String date = formatter.format(cal3.getTime());

9. String 和 Date ，Long 之间相互转换 （最常用）

字符串转化成时间类型（字符串可以是任意类型，只要和SimpleDateFormat中的格式一致即可）
通常我们取时间跨度的时候，会substring出具体时间－－long－比较

java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("M/dd/yyyy hh:mm:ss a",java.util.Locale.US);
java.util.Date d = sdf.parse("5/13/2003 10:31:37 AM");
long dvalue=d.getTime();
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String mDateTime1=formatter.format(d);

10. 通过时间求时间

年月周求日期
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);

求是星期几
mydate= myFormatter.parse("2001-1-1");
SimpleDateFormat formatter4 = new SimpleDateFormat("E");
String mydate3=formatter4.format(mydate);

11. java 和 具体的数据库结合

在开发web应用中，针对不同的数据库日期类型，我们需要在我们的程序中对日期类型做各种不同的转换。若对应数据库数据是oracle的Date类 型，即只需要年月日的，可以选择使用java.sql.Date类型，若对应的是MSsqlserver 数据库的DateTime类型，即需要年月日时分秒的，选择java.sql.Timestamp类型
你可以使用dateFormat定义时间日期的格式，转一个字符串即可

class Datetest{
*method 将字符串类型的日期转换为一个timestamp（时间戳记java.sql.Timestamp）
*@param dateString 需要转换为timestamp的字符串
*@return dataTime timestamp

public final static java.sql.Timestamp string2Time(String dateString)
throws java.text.ParseException {
DateFormat dateFormat;
dateFormat = new SimpleDateFormat("yyyy-MM-dd kk:mm:ss.SSS", Locale.ENGLISH);//设定格式
//dateFormat = new SimpleDateFormat("yyyy-MM-dd kk:mm:ss", Locale.ENGLISH);
dateFormat.setLenient(false);
java.util.Date timeDate = dateFormat.parse(dateString);//util类型
java.sql.Timestamp dateTime = new java.sql.Timestamp(timeDate.getTime());//Timestamp类型,timeDate.getTime()返回一个long型
return dateTime;
}

*method 将字符串类型的日期转换为一个Date（java.sql.Date）
*@param dateString 需要转换为Date的字符串
*@return dataTime Date

public final static java.sql.Date string2Date(String dateString)
throws java.lang.Exception {
DateFormat dateFormat;
dateFormat = new SimpleDateFormat("yyyy-MM-dd", Locale.ENGLISH);
dateFormat.setLenient(false);
java.util.Date timeDate = dateFormat.parse(dateString);//util类型
java.sql.Date dateTime = new java.sql.Date(timeDate.getTime());//sql类型
return dateTime;
}

public static void main(String[] args){
Date da = new Date();
注意：这个地方da.getTime()得到的是一个long型的值
System.out.println(da.getTime());

由日期date转换为timestamp

第一种方法：使用new Timestamp(long)
Timestamp t = new Timestamp(new Date().getTime());
System.out.println(t);

第二种方法：使用Timestamp(int year,int month,int date,int hour,int minute,int second,int nano)
Timestamp tt = new Timestamp(Calendar.getInstance().get(
      Calendar.YEAR) - 1900, Calendar.getInstance().get(
      Calendar.MONTH), Calendar.getInstance().get(
      Calendar.DATE), Calendar.getInstance().get(
      Calendar.HOUR), Calendar.getInstance().get(
      Calendar.MINUTE), Calendar.getInstance().get(
      Calendar.SECOND), 0);
System.out.println(tt);

try {
String sToDate = "2005-8-18";//用于转换成java.sql.Date的字符串
      String sToTimestamp = "2005-8-18 14:21:12.123";//用于转换成java.sql.Timestamp的字符串
      Date date1 = string2Date(sToDate);
      Timestamp date2 = string2Time(sToTimestamp);
System.out.println("Date:"+date1.toString());//结果显示
System.out.println("Timestamp:"+date2.toString());//结果显示
}catch(Exception e) {
e.printStackTrace();
}
}
}

一、Date的构造函数

1.1构造一个反映当时时间的Date实例
Date
public Date()
构造一个Date对象并对其进行初始化以反映当前时间。

1.2从一个长整型数据构造一个Date实例
Date
public Date(long date)
构造一个Date对象，并根据相对于GMT 1970年1月1日00:00:00的毫秒数对其进行初始化。 
参数： 
date - 相对于GMT 1970年1月1日00:00:00的毫秒数。

1.3从年月日时分秒构造一个Date实例
Date
public Date(int year,
int month,
int date)
public Date(int year,
int month,
int date,
int hrs,
int min)
public Date(int year,
int month,
int date,
int hrs,
int min,
int sec)
这三个构造函数均不推荐使用，在JDK 1.1版中，分别被Calendar.set(year + 1900, month, date)或GregorianCalendar(year + 1900, month, date)、Calendar.set(year + 1900, month, date, hrs, min)或 GregorianCalendar(year + 1900, month, date, hrs, min)、Calendar.set(year + 1900, month, date, hrs, min, sec)或GregorianCalendar(year + 1900, month, date, hrs, min, sec)代替。

——————————————————————————————————————————————

Java中Calendar.DAY_OF_WEEK需要减一的原因

Java中对日期的处理需要用到Calendar类，其中有几个方法在使用时需要新手注意。

1. 在获取月份时，Calendar.MONTH + 1 的原因
Java中的月份遵循了罗马历中的规则：当时一年中的月份数量是不固定的，第一个月是JANUARY。而Java中Calendar.MONTH返回的数值其实是当前月距离第一个月有多少个月份的数值，JANUARY在Java中返回“0”，所以我们需要+1。

2. 在获取星期几 Calendar.DAY_OF_WEEK – 1 的原因
Java中Calendar.DAY_OF_WEEK其实表示：一周中的第几天，所以他会受到 第一天是星期几 的影响。
有些地区以星期日作为一周的第一天，而有些地区以星期一作为一周的第一天，这2种情况是需要区分的。
看下表的返回值

星期日为一周的第一天	SUN	MON	TUE	WED	THU	FRI	SAT
DAY_OF_WEEK返回值	1	2	3	4	5	6	7
星期一为一周的第一天	MON	TUE	WED	THU	FRI	SAT	SUN
DAY_OF_WEEK返回值	1	2	3	4	5	6	7

所以Calendar.DAY_OF_WEEK需要根据本地化设置的不同而确定是否需要 “-1”
Java中设置不同地区的输出可以使用 Locale.setDefault(Locale.地区名) 来实现。

3. 获取日期时 Calendar.DAY_OF_MONTH 不需要特殊的操作，他直接返回一个月中的第几天

————————————————————————————————————————————————————————————————

在开发中经常会使用到一些日期方面的操作，下面例子展示几个常用的操作。

1、取得指定日期是星期几

取得指定日期是星期几可以采用下面两种方式取得日期是星期几：

a、使用Calendar类

1. //根据日期取得星期几
2. public static String getWeek(Date date){
3. String[] weeks = {"星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
4. Calendar cal = Calendar.getInstance();
5. cal.setTime(date);
6. int week_index = cal.get(Calendar.DAY_OF_WEEK) - 1;
7. if(week_index<0){
8. week_index = 0;
9. }
10. return weeks[week_index];
11. }

b、使用SimpleDateFormat类

1. //根据日期取得星期几
2. public static String getWeek(Date date){
3. SimpleDateFormat sdf = new SimpleDateFormat("EEEE");
4. String week = sdf.format(date);
5. return week;
6. }

注：格式化字符串存在区分大小写
对于创建SimpleDateFormat传入的参数：EEEE代表星期，如“星期四”；MMMM代表中文月份，如“十一月”；MM代表月份，如“11”；
yyyy代表年份，如“2010”；dd代表天，如“25”

2、取得日期是某年的第几周

根据日期入得日期是某年的第几周。

1. //取得日期是某年的第几周
2. public static int getWeekOfYear(Date date){
3. Calendar cal = Calendar.getInstance();
4. cal.setTime(date);
5. int week_of_year = cal.get(Calendar.WEEK_OF_YEAR);
6. return week_of_year;
7. }

3、得到某年的某个月有多少天

已知年份和月份，取得该月有多少天。

1. //取得某个月有多少天
2. public static int getDaysOfMonth(int year,int month){
3. Calendar cal = Calendar.getInstance();
4. cal.set(Calendar.YEAR, year);
5. cal.set(Calendar.MONTH, month-1);
6. int days_of_month = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
7. return days_of_month;
8. }

4、取得两个日期之间的相差多少天

已知两个日期，计算它们之间相差多少天。

1. <pre name="code" class="java">// 取得两个日期之间的相差多少天
2. public static long getDaysBetween(Date date0, Date date1) {
3. long daysBetween = (date0.getTime() - date1.getTime() + 1000000) / 86400000;// 86400000=3600*24*1000  用立即数，减少乘法计算的开销
4. return daysBetween;
5. }</pre>
6. <pre></pre>
7. <pre></pre>
8. <pre></pre>
9. <pre></pre>
10. <pre></pre>

5、完整的测试代码

1. package org.ml.test;
2. import java.text.ParseException;
3. import java.text.SimpleDateFormat;
4. import java.util.Calendar;
5. import java.util.Date;
6. public class CalendarDemo {
7. public static void main(String[] args) {
8. String strDate = "2013-03-08";// 定义日期字符串
9. SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");// 定义日期格式
10. Date date = null;
11. try {
12. date = format.parse(strDate);// 将字符串转换为日期
13. } catch (ParseException e) {
14. System.out.println("输入的日期格式不合理！");
15. }
16. System.out.println(strDate + "是:" + getWeek(date));
17. System.out.println(strDate + "是一年的第:" + getWeekOfYear(date) + "周");
18. System.out.println(strDate + "是一年的" + (date.getMonth() + 1) + "月有:"
19. + getDaysOfMonth(date.getYear(), date.getMonth() + 1) + "天");
20. System.out.println(strDate + "距离" + (format.format(new Date())) + "还有"
21. + getDaysBetween(date, new Date()) + "天");
22. }
23. // 根据日期取得星期几
24. public static String getWeek(Date date) {
25. // String[] weeks = {"星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
26. // Calendar cal = Calendar.getInstance();
27. // cal.setTime(date);
28. // int week_index = cal.get(Calendar.DAY_OF_WEEK) - 1;
29. // if(week_index<0){
30. // week_index = 0;
31. // }
32. // return weeks[week_index];
33. SimpleDateFormat sdf = new SimpleDateFormat("EEEE");
34. String week = sdf.format(date);
35. return week;
36. }
37. // 取得日期是某年的第几周
38. public static int getWeekOfYear(Date date) {
39. Calendar cal = Calendar.getInstance();
40. cal.setTime(date);
41. int week_of_year = cal.get(Calendar.WEEK_OF_YEAR);
42. return week_of_year;
43. }
44. // 取得某个月有多少天
45. public static int getDaysOfMonth(int year, int month) {
46. Calendar cal = Calendar.getInstance();
47. cal.set(Calendar.YEAR, year);
48. cal.set(Calendar.MONTH, month-1);
49. int days_of_month = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
50. return days_of_month;
51. }
52. // 取得两个日期之间的相差多少天
53. public static long getDaysBetween(Date date0, Date date1) {
54. long daysBetween = (date0.getTime() - date1.getTime() + 1000000) / 86400000;// 86400000=3600*24*1000  用立即数，减少乘法计算的开销
55. return daysBetween;
56. }
57. }

6、测试结果

7、引出的问题

看下面的代码：

1. public static void main(String[] args) throws Exception{
2. String strDate = "999-999-999";// 定义日期字符串
3. SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");// 定义日期格式
4. Date date = null;
5. try {
6. date = format.parse(strDate);// 将字符串转换为日期
7. } catch (ParseException e) {
8. System.out.println("日期格式有误，请给出正确的日期格式");
9. return;
10. }
11. System.out.println(format.format(date));
12. }

Java中使用yyyy-MM-dd日期格式进行转换，转换字符串为999-999-999时，没有出现异常，反倒是执行通过了。

运行结果：1084-11-23

解决办法如下：

在date = format.parse(strDate)前面加上format.setLenient(false)就行了。意思是【指定日期/时间解析是否不严格。进行不严格解析时，解析程序可以使用启发式的方法来解释与此对象的格式不精确匹配的输入。进行严格解析时，输入必须匹配此对象的格式。 】

截取到天，小时，分。。。。。

Date date = new Date();
    DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
    
    System.out.println(dateFormat.format(DateUtils.truncate(date, Calendar.HOUR_OF_DAY)));
    //2009-08-04 16:00:00
    System.out.println(dateFormat.format(DateUtils.truncate(date, Calendar.MINUTE)));//2009-08-04 16:23:00
    System.out.println(dateFormat.format(DateUtils.truncate(date, Calendar.SECOND))); //2009-08-04 16:23:14
    
    System.out.println(dateFormat.format(DateUtils.truncate(date, Calendar.DAY_OF_MONTH)));
      //2009-08-04 00:00:00
    System.out.println(dateFormat.format(DateUtils.truncate(date, Calendar.MONTH))); //2009-08-01 00:00:00
    System.out.println(dateFormat.format(DateUtils.truncate(date, Calendar.YEAR))); //2009-01-01 00:00:00

______________________________________________________

Calendar.HOUR_OF_DAY是24小时制

Calendar.HOUR是12小时制

因此

calendar.set(Calendar.HOUR_OF_DAY, 15);和calendar.set(Calendar.HOUR, 15);

操作作结果有差异．

calendar.set(Calendar.HOUR, 0);是设置成了12点？？？？？？？？？？？？？？？？？？奇怪。