精华内容
下载资源
问答
  • java的date类

    千次阅读 2008-11-22 20:09:00
    java的date类(1) Date类可以在java.util包中找到,用一个long类型的值表示一个指定的时刻。它的一个有用的构造函数是Date(),它创建一个表示创建时刻的对象。getTime()方法返回Date对象的long值。下面用Date()构造...
     
    java的date类(1)
        Date类可以在java.util包中找到,用一个long类型的值表示一个指定的时刻。它的一个有用的构造函数是Date(),它创建一个表示创建时 刻的对象。getTime()方法返回Date对象的long值。下面用Date()构造函数创建一个表示程序运行时刻的对象,并且利用 getTime()方法找到这个日期代表的毫秒数量:
       import java.util.*;
       public class Now
       {
         public static void main(String[] args) {
         Date now = new Date();
         long nowLong = now.getTime();
         System.out.println("Value is " + nowLong);
        }
       }
        运行这个程序,得到一个数字,起码在一个合理的范围是合理的。计算机是这个毫秒值表示时间,Java提供了一个转换Date对象到字符串的途径,表示成传 统的形式。DateFormat类(DateFormat类在java.text包中可以找到),便直观的建立日期字符串。
        DateFormat类的一个目标是建立一个人们能够识别的字符串。一个DateFormat的实例创建以后,这个对象包含了日期的显示格式的信息。如果 使用区域设置缺省的格式,可如下创建DateFormat对象,使用getDateInstance()方法:
              DateFormat df = DateFormat.getDateInstance();
        可使用format()方法转换Date对象为一个字符串。如下:
       import java.util.*;
       import java.text.*;
       public class NowString
       {
         public static void main(String[] args) {
         Date now = new Date();
         DateFormat df = DateFormat.getDateInstance();
         String s = df.format(now);
         System.out.println("Today is " + s);
        }
       }
        上代码中,使用缺省格式的、没有参数的getDateInstance()方法。Java还提供了几个选择日期格式,可以通过使用重载的 getDateInstance(int style)获得。DateFormat也提供了几种预置的常量,可用这些常量参数。下面是几个SHORT, MEDIUM, LONG, 和FULL类型的示例:
       import java.util.*;
       import java.text.*;   
       public class StyleDemo
       {
         public static void main(String[] args)
         {
           Date now = new Date();
          
           DateFormat df = DateFormat.getDateInstance();
           DateFormat df1 = DateFormat.getDateInstance(DateFormat.SHORT);
           DateFormat df2 = DateFormat.getDateInstance(DateFormat.MEDIUM);
           DateFormat df3 = DateFormat.getDateInstance(DateFormat.LONG);
           DateFormat df4 = DateFormat.getDateInstance(DateFormat.FULL);
           String s = df.format(now);
           String s1 = df1.format(now);
           String s2 = df2.format(now);
           String s3 = df3.format(now);
           String s4 = df4.format(now);
          
           System.out.println("(Default) Today is " + s);
           System.out.println("(SHORT) Today is " + s1);
           System.out.println("(MEDIUM) Today is " + s2);
           System.out.println("(LONG) Today is " + s3);
           System.out.println("(FULL) Today is " + s4);
         }
          }
        可用getDateInstance()方法改变DateFormat实例的语种;不同的地方的区域设置不同,结果就不同,如果程序员依靠日期格式编程,日期格式将根据运行程序所在电脑的区域设置不用而不同。
        解析字符串。通过parse()方法,DateFormat能够以一个字符串创立一个Date对象。这个方法能抛出ParseException异常,则必用适当的异常处理技术。下面的例子程序通过字符串创建Date对象:
       import java.util.*;
       import java.text.*;
       public class ParseExample
       {
         public static void main(String[] args)
         {
           String ds = "November 1, 2000";
           DateFormat df = DateFormat.getDateInstance();
           try {
              Date d = df.parse(ds);
           }
           catch(ParseException e) {
              System.out.println("Unable to parse " + ds);
           }
         }
       }
        在创建一个任意的日期时parse()方法很有用。可通过另一种方法创建一个任意得日期,并进行基本日期计算,例如计算90天后的另一天。你可以使用GregorianCalendar类来完成这个任务。
        GregorianCalendar类 创建一个代表任意日期的一个途径使用GregorianCalendar类的构造函数,它包含在java.util包中:
               GregorianCalendar(int year, int month, int date)
        其中月份的表示,一月是0,二月是1,以此类推,是12月是11。因为大多数人习惯于使用单词而不是使用数字来表示月份,更易读,父类 Calendar使用常量来表示月份:JANUARY, FEBRUARY,等等。所以,创建Wilbur 和 Orville制造第一架动力飞机的日期(December 17, 1903),你可以使用:
               GregorianCalendar firstFlight = new GregorianCalendar(1903, Calendar.DECEMBER, 17);
    下面的例子同样表示December 17,1903(记住,在短格式中,11表示December)
               GregorianCalendar firstFlight = new GregorianCalendar(1903, 11, 17);
        使用getTime()方法,从它得父类Calendar继承而来。GetTime()方法返回GregorianCalendar 相应的Date对象。你能够创建GregorianCalendar对象,转换到Date对象,得到和输出相应的字符串。下面是例子:
       import java.util.*;
       import java.text.*;
       public class Flight
       {
         public static void main(String[] args)
         {
          GregorianCalendar firstFlight = new GregorianCalendar(1903, Calendar.DECEMBER, 17);
          Date d = firstFlight.getTime();
          DateFormat df = DateFormat.getDateInstance();
          String s = df.format(d);
          System.out.println("First flight was " + s);
         }
       }
        有时创建一个代表当前时刻的GregorianCalendar类的实例是很有用的。可用没有参数的GregorianCalendar构造函数,一个输出今天日期的例子程序,使用GregorianCalendar对象:
       import java.util.*;
       import java.text.*;
       class Today {
         public static void main(String[] args)
         {
           GregorianCalendar thisday = new GregorianCalendar();
           Date d = thisday.getTime();
           DateFormat df = DateFormat.getDateInstance();
           String s = df.format(d);
           System.out.println("Today is " + s);
         }
       }
           其实,Date()构造函数和GregorianCalendar()构造函数很类似:都创建一个对象,条件简单,代表今天。
     
    日期处理
       GregorianCalendar 类提供处理日期的方法。一个有用的方法是add(),使用add()方法,可增加年,月数,天数到日期对象中。但必须提供要增加的字段,要增加的数量。字 段有DATE, MONTH, YEAR, 和 WEEK_OF_YEAR。下面是使用add()方法计算未来80天的一个日期。
       import java.util.*;
       import java.text.*;
       public class World
       {
         public static void main(String[] args)
         {
           GregorianCalendar worldTour = new GregorianCalendar(2005, Calendar.OCTOBER, 30);
           worldTour.add(GregorianCalendar.DATE, 80);
           Date d = worldTour.getTime();
           DateFormat df = DateFormat.getDateInstance();
           String s = df.format(d);
           System.out.println("80 day trip will end " + s);
         }
       }
        这个例子是想象的,但在一个日期上增加天数是一个普遍的操作:图书馆可以借书30天,下面的程序演示了使用年计算:
       import java.util.*;
       import java.text.*;
       public class Mortgage
       {
         public static void main(String[] args)
         {
           GregorianCalendar mortgage = new GregorianCalendar(2005, Calendar.JULY, 1);
           mortgage.add(Calendar.YEAR, 15);
           Date d = mortgage.getTime();
           DateFormat df = DateFormat.getDateInstance();
           String s = df.format(d);
           System.out.println("15 year mortgage amortized on " + s);
         }
       }
        方法add ()的一个重要副作用是改变原来的日期。不能简单的创建一个 GregorianCalendar对象,设置它和原来的相等(equal)。原因是两个变量指向同一个Date()对象地址。如果Date对象改变,两 个变量就指向改变后的日期对象。代替这种做法,应该创建一个新对象。下面的程序示范了这种做法:
       import java.util.*;
       import java.text.*;   
       public class ThreeDates
       {
         public static void main(String[] args)
         {
           GregorianCalendar gc1 = new GregorianCalendar(2005, Calendar.OCTOBER, 1);
           GregorianCalendar gc2 = gc1;
           GregorianCalendar gc3 = new GregorianCalendar(2005, Calendar.OCTOBER, 1);
           //Three dates all equal to OCTOBER 1, 2005
          
           gc1.add(Calendar.YEAR, 1);
           // gc1 and gc2 are changed
          
           DateFormat df = DateFormat.getDateInstance();      
           Date d1 = gc1.getTime();
           Date d2 = gc2.getTime();
           Date d3 = gc3.getTime();
          
           String s1 = df.format(d1);
           String s2 = df.format(d2);
           String s3 = df.format(d3);
          
           System.out.println("gc1 is " + s1);
           System.out.println("gc2 is " + s2);
           System.out.println("gc3 is " + s3);
         }
       }
        程序运行后,gc1和gc2被变成2001年(因为两个对象指向同一个Date,而Date已经被改变了)。对象gc3指向一个单独的Date,它没有被改变。
    展开全文
  • JAVA的Date类与Calendar类

    2014-04-15 14:54:11
    JAVA的Date类与Calendar类【转】 Posted on 2009-12-03 16:56 火之光 阅读(10578) 评论(3) 编辑 收藏 Date类 在JDK1.0中,Date类是唯一的一个代表时间的类,但是由于Date类不便于实现国际化,所以从JDK...
    JAVA的Date类与Calendar类【转】


    Posted on 2009-12-03 16:56 火之光 阅读(10578) 评论(3) 编辑 收藏
    Date类


    在JDK1.0中,Date类是唯一的一个代表时间的类,但是由于Date类不便于实现国际化,所以从JDK1.1版本开始,推荐使用Calendar类进行时间和日期处理。这里简单介绍一下Date类的使用。


    1、使用Date类代表当前系统时间


                       Date d = new Date();


                       System.out.println(d);


    使用Date类的默认构造方法创建出的对象就代表当前时间,由于Date类覆盖了toString方法,所以可以直接输出Date类型的对象,显示的结果如下:
                                Sun Mar 08 16:35:58 CST 2009


    在该格式中,Sun代表Sunday(周日),Mar代表March(三月),08代表8号,CST代表China Standard Time(中国标准时间,也就是北京时间(东八区))。
             2、使用Date类代表指定的时间


                                Date d1 = new Date(2009-1900,3-1,9);


                                System.out.println(d1);


    使用带参数的构造方法,可以构造指定日期的Date类对象,Date类中年份的参数应该是实际需要代表的年份减去1900,实际需要代表的月份减去1以后的值。例如上面的示例代码代表就是2009年3月9号。
    实际代表具体的年月日时分秒的日期对象,和这个类似。
             3、获得Date对象中的信息


                                Date d2 = new Date();


                       //年份
                       int year = d2.getYear() + 1900;
                       //月份
                       int month = d2.getMonth() + 1;
                       //日期
                       int date = d2.getDate();
                       //小时
                       int hour = d2.getHours();
                       //分钟
                       int minute = d2.getMinutes();
                       //秒
                       int second = d2.getSeconds();
                       //星期几
                       int day = d2.getDay();
                       System.out.println("年份:" + year);
                       System.out.println("月份:" + month);
                       System.out.println("日期:" + date);
                       System.out.println("小时:" + hour);
                       System.out.println("分钟:" + minute);
                       System.out.println("秒:" + second);
                       System.out.println("星期:" + day);
             使用Date类中对应的get方法,可以获得Date类对象中相关的信息,需要注意的是使用getYear获得是Date对象中年份减去1900以后的值,所以需要显示对应的年份则需要在返回值的基础上加上1900,月份类似。在Date类中还提供了getDay方法,用于获得Date对象代表的时间是星期几,Date类规定周日是0,周一是1,周二是2,后续的依次类推。
    4、Date对象和相对时间之间的互转
                      Date d3 = new Date(2009-1900,3-1,10);
                       long time = 1290876532190L;
                       //将Date类的对象转换为相对时间
                       long t = d3.getTime();
                       System.out.println(t);
                       //将相对时间转换为Date类的对象
                       Date d4 = new Date(time);
                       System.out.println(d4);
             使用Date对象中的getTime方法,可以将Date类的对象转换为相对时间,使用Date类的构造方法,可以将相对时间转换为Date类的对象。经过转换以后,既方便了时间的计算,也使时间显示比较直观了。
     Calendar类


    从JDK1.1版本开始,在处理日期和时间时,系统推荐使用Calendar类进行实现。在设计上,Calendar类的功能要比Date类强大很多,而且在实现方式上也比Date类要复杂一些,下面就介绍一下Calendar类的使用。


    Calendar类是一个抽象类,在实际使用时实现特定的子类的对象,创建对象的过程对程序员来说是透明的,只需要使用getInstance方法创建即可。


    1、使用Calendar类代表当前时间


                       Calendar c = Calendar.getInstance();


    由于Calendar类是抽象类,且Calendar类的构造方法是protected的,所以无法使用Calendar类的构造方法来创建对象,API中提供了getInstance方法用来创建对象。
    使用该方法获得的Calendar对象就代表当前的系统时间,由于Calendar类toString实现的没有Date类那么直观,所以直接输出Calendar类的对象意义不大。
    2、使用Calendar类代表指定的时间


                       Calendar c1 = Calendar.getInstance();


                       c1.set(2009, 3 - 1, 9);


    使用Calendar类代表特定的时间,需要首先创建一个Calendar的对象,然后再设定该对象中的年月日参数来完成。
    set方法的声明为:
             public final void set(int year,int month,int date)
    以上示例代码设置的时间为2009年3月9日,其参数的结构和Date类不一样。Calendar类中年份的数值直接书写,月份的值为实际的月份值减1,日期的值就是实际的日期值。
    如果只设定某个字段,例如日期的值,则可以使用如下set方法:
             public void set(int field,int value)
    在该方法中,参数field代表要设置的字段的类型,常见类型如下:
             Calendar.YEAR——年份
             Calendar.MONTH——月份
             Calendar.DATE——日期
             Calendar.DAY_OF_MONTH——日期,和上面的字段完全相同
             Calendar.HOUR——12小时制的小时数
             Calendar.HOUR_OF_DAY——24小时制的小时数
             Calendar.MINUTE——分钟
             Calendar.SECOND——秒
             Calendar.DAY_OF_WEEK——星期几
    后续的参数value代表,设置成的值。例如:
             c1.set(Calendar.DATE,10);
    该代码的作用是将c1对象代表的时间中日期设置为10号,其它所有的数值会被重新计算,例如星期几以及对应的相对时间数值等。
    3、获得Calendar类中的信息


                       Calendar c2 = Calendar.getInstance();


                       //年份


                       int year = c2.get(Calendar.YEAR);


                       //月份


                       int month = c2.get(Calendar.MONTH) + 1;


                       //日期


                       int date = c2.get(Calendar.DATE);


                       //小时


                       int hour = c2.get(Calendar.HOUR_OF_DAY);


                       //分钟


                       int minute = c2.get(Calendar.MINUTE);


                       //秒


                       int second = c2.get(Calendar.SECOND);


                       //星期几


                       int day = c2.get(Calendar.DAY_OF_WEEK);


                       System.out.println("年份:" + year);


                       System.out.println("月份:" + month);


                       System.out.println("日期:" + date);


                       System.out.println("小时:" + hour);


                       System.out.println("分钟:" + minute);


                       System.out.println("秒:" + second);


                       System.out.println("星期:" + day);


    使用Calendar类中的get方法可以获得Calendar对象中对应的信息,get方法的声明如下:
             public int get(int field)
    其中参数field代表需要获得的字段的值,字段说明和上面的set方法保持一致。需要说明的是,获得的月份为实际的月份值减1,获得的星期的值和Date类不一样。在Calendar类中,周日是1,周一是2,周二是3,依次类推。
    4、其它方法说明


    其实Calendar类中还提供了很多其它有用的方法,下面简单的介绍几个常见方法的使用。
    a、add方法
                       public abstract void add(int field,int amount)
    该方法的作用是在Calendar对象中的某个字段上增加或减少一定的数值,增加是amount的值为正,减少时amount的值为负。
             例如在计算一下当前时间100天以后的日期,代码如下:
                       Calendar c3 = Calendar.getInstance();
                       c3.add(Calendar.DATE, 100);
                       int year1 = c3.get(Calendar.YEAR);
                       //月份
                       int month1 = c3.get(Calendar.MONTH) + 1;
                       //日期
                       int date1 = c3.get(Calendar.DATE);
                       System.out.println(year1 + "年" + month1 + "月" + date1 + "日");
    这里add方法是指在c3对象的Calendar.DATE,也就是日期字段上增加100,类内部会重新计算该日期对象中其它各字段的值,从而获得100天以后的日期,例如程序的输出结果可能为:
                       2009年6月17日
    b、after方法
                       public boolean after(Object when)
    该方法的作用是判断当前日期对象是否在when对象的后面,如果在when对象的后面则返回true,否则返回false。例如:
                       Calendar c4 = Calendar.getInstance();
                       c4.set(2009, 10 - 1, 10);
                       Calendar c5 = Calendar.getInstance();
                       c5.set(2010, 10 - 1, 10);
                       boolean b = c5.after(c4);
                       System.out.println(b);
    在该示例代码中对象c4代表的时间是2009年10月10号,对象c5代表的时间是2010年10月10号,则对象c5代表的日期在c4代表的日期之后,所以after方法的返回值是true。
    另外一个类似的方法是before,该方法是判断当前日期对象是否位于另外一个日期对象之前。
                       c、getTime方法


                                         public final Date getTime()


    该方法的作用是将Calendar类型的对象转换为对应的Date类对象,两者代表相同的时间点。
    类似的方法是setTime,该方法的作用是将Date对象转换为对应的Calendar对象,该方法的声明如下:
             public final void setTime(Date date)
    转换的示例代码如下:
                      Date d = new Date();
                       Calendar c6 = Calendar.getInstance();
                       //Calendar类型的对象转换为Date对象
                       Date d1 = c6.getTime();
                       //Date类型的对象转换为Calendar对象
                       Calendar c7 = Calendar.getInstance();
                       c7.setTime(d);
             5、Calendar对象和相对时间之间的互转


                                Calendar c8 = Calendar.getInstance();


                                long t = 1252785271098L;


                                //将Calendar对象转换为相对时间


                                long t1 = c8.getTimeInMillis();


                                //将相对时间转换为Calendar对象


                                Calendar c9 = Calendar.getInstance();


                                c9.setTimeInMillis(t1);


    在转换时,使用Calendar类中的getTimeInMillis方法可以将Calendar对象转换为相对时间。在将相对时间转换为Calendar对象时,首先创建一个Calendar对象,然后再使用Calendar类的setTimeInMillis方法设置时间即可。
    应用示例


             下面以两个简单的示例介绍时间和日期处理的基本使用。


             1、计算两个日期之间相差的天数


    例如计算2010年4月1号和2009年3月11号之间相差的天数,则可以使用时间和日期处理进行计算。
    该程序实现的原理为:首先代表两个特定的时间点,这里使用Calendar的对象进行代表,然后将两个时间点转换为对应的相对时间,求两个时间点相对时间的差值,然后除以1天的毫秒数(24小时X60分钟X60秒X1000毫秒)即可获得对应的天数。实现该示例的完整代码如下:
             import java.util.*;
    /**
     * 计算两个日期之间相差的天数
     */
    public class DateExample1 {
             public static void main(String[] args) {
                       //设置两个日期
                       //日期:2009年3月11号
                       Calendar c1 = Calendar.getInstance();
                       c1.set(2009, 3 - 1, 11);
                       //日期:2010年4月1号
                       Calendar c2 = Calendar.getInstance();
                       c2.set(2010, 4 - 1, 1);
                       //转换为相对时间
                       long t1 = c1.getTimeInMillis();
                       long t2 = c2.getTimeInMillis();
                       //计算天数
                       long days = (t2 - t1)/(24 * 60 * 60 * 1000);
                       System.out.println(days);
             }
    }
             2、输出当前月的月历


    该示例的功能是输出当前系统时间所在月的日历,例如当前系统时间是2009年3月10日,则输出2009年3月的日历。
    该程序实现的原理为:首先获得该月1号是星期几,然后获得该月的天数,最后使用流程控制实现按照日历的格式进行输出即可。即如果1号是星期一,则打印一个单位的空格,如果1号是星期二,则打印两个单位的空格,依次类推。打印完星期六的日期以后,进行换行。实现该示例的完整代码如下:
             import java.util.*;
    /**
     * 输出当前月的日历
     */
    public class DateExample2{
             public static void main(String[] args){
                       //获得当前时间
                       Calendar c = Calendar.getInstance();
                       //设置代表的日期为1号
                       c.set(Calendar.DATE,1);
                       //获得1号是星期几
                       int start = c.get(Calendar.DAY_OF_WEEK);
                       //获得当前月的最大日期数
                       int maxDay = c.getActualMaximum(Calendar.DATE);   
                      
                       //输出标题
                       System.out.println("星期日 星期一 星期二 星期三 星期四 星期五   星期六");
                       //输出开始的空格
                       for(int i = 1;i < start;i++){
                                System.out.print("      "); 
                       }
                       //输出该月中的所有日期
                       for(int i = 1;i <= maxDay;i++){
                                //输出日期数字
                                System.out.print(" " + i);
                                //输出分隔空格
                                System.out.print("     ");
                                if(i < 10){
                                         System.out.print(' ');
                                }
                                //判断是否换行
                                if((start + i - 1) % 7 == 0){
                                         System.out.println();       
                                }
                       }
                       //换行
                       System.out.println();       
             }       
    }

             关于时间和日期的处理就介绍这么多,更多的实现方法还需要根据具体问题进行对应的实现。













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

      Java代码

      Calendar time=Calendar.getInstance();

      time.clear();

      time.set(Calendar.YEAR,year);

      time.set(Calendar.MONTH,i-1);//注意,Calendar对象默认一月为0

      int day=time.getActualMaximum(Calendar.DAY_OF_MONTH);//本月份的天数

      注:在使用set方法之前,必须先clear一下,否则很多信息会继承自系统当前时间

      2.Calendar和Date的转化

      (1) Calendar转化为Date

      Java代码

      Calendar cal=Calendar.getInstance();

      Date date=cal.getTime();

      (2) Date转化为Calendar

      Java代码

      Date date=new Date();

      Calendar cal=Calendar.getInstance();

      cal.setTime(date);

      3.格式化输出日期时间

      Java代码

      Date date=new Date();

      SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

      System.out.println(df.format(date));

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

      (1)计算某一天是一年中的第几星期

      Java代码

      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)计算一年中的第几星期是几号

      Java代码

      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

      5.add()和roll()的用法

      (1)add()方法

      Java代码

      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方法

      Java代码

      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()方法;


    6.计算两个任意时间中间的间隔天数

      (1)传进Calendar对象

      Java代码

      /** *//**计算两个时间之间相隔天数

      * @param startday 开始时间

      * @param endday 结束时间

      * @return

      */

      public int getIntervalDays(Calendar startday,Calendar endday)...{

      //确保startday在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对象

      Java代码

      /** *//**计算两个时间之间相隔天数

      * @param startday 开始时间

      * @param endday 结束时间

      * @return

      */

      public int getIntervalDays(Date startday,Date endday)...{

      //确保startday在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));

      }

      同理,可以用相同的方法计算出任意两个时间相隔的小时数,分钟数,秒钟数等

      注:以上方法是完全按时间计算,有时并不能令人满意,如:

      startday="2006-10-11 20:00:00"

      endday="2006-10-12 8:00:00"

      计算结果为0,但是我们也许相让计算结果变为1,此时可以用如下方法实现:

      在传参之前,先设定endday的时间,如:

      Java代码

      endday.set(Calendar.HOUR_OF_DAY, 23);

      endday.set(Calendar.MINUTE, 59);

      endday.set(Calendar.SECOND, 59);

      endday.set(Calendar.MILLISECOND, 59);

      这样再传进去startday,endday,则结果就如我们所愿了。不过,如果嫌以上方法麻烦,可以参考以下方法:

      (3)改进精确计算相隔天数的方法

      Java代码

      public int getDaysBetween (Calendar d1, Calendar d2) ...{

      if (d1.after(d2)) ...{ // swap dates so that d1 is start and d2 is end

      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_OF_YEAR);//得到当年的实际天数

      d1.add(Calendar.YEAR, 1);

      } while (d1.get(Calendar.YEAR) != y2);

      }

      return days;

      }

    获取系统当前时间:

      Java代码

      public static String getSystemTime(){

      Date date=new Date();

      SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

      return df.format(date);

      }

      //字符串转化成时间类型(字符串可以是任意类型,只要和SimpleDateFormat中的格式一致即可)

      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");

      SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

      String mDateTime1=formatter.format(d);

      //当前时间

      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());

      //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);

      //明天日期

      myDate=new java.util.Date();

      myTime=(myDate.getTime()/1000)+60*60*24;

      myDate.setTime(myTime*1000);

      mDate=formatter.format(myDate);

      //两个时间之间的天数

      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);

      //加半小时

      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);

      //年月周求日期

      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);

      }

      在 开发web应用中,针对不同的数据库日期类型,我们需要在我们的程序中对日期类型做各种不同的转换。若对应数据库数据是oracle的Date类型,即只 需要年月日的,可以选择使用java.sql.Date类型,若对应的是MSsqlserver数据库的DateTime类型,即需要年月日时分秒的,选 择java.sql.Timestamp类型

      你可以使用dateFormat定义时间日期的格式,转一个字符串即可

      Java代码

      package personal.jessica;

      import java.util.Date;

      import java.util.Calendar;

      import java.sql.Timestamp;

      import java.text.DateFormat;

      import java.text.SimpleDateFormat;

      import java.util.Locale;

      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();

      }

      }

      }

      Java获取系统时间的年份

      Java代码

      public static String getYear(){

      Calendar ca = Calendar.getInstance();

      ca.setTime(new java.util.Date());

      String year = ""+ca.get(Calendar.YEAR);

      return year;

      }

      public void getYear(){

      Calendar ca = Calendar.getInstance();

      ca.setTime(new java.util.Date());

      SimpleDateFormat simpledate = new SimpleDateFormat("yyyyMMdd");

      String date = simpledate.format(ca.getTime());

      int year = ca.get(Calendar.YEAR);

      int month = ca.get(Calendar.MONTH);

      int day = ca.get(Calendar.DAY_OF_MONTH);

      System.out.println(date+"||"+year+"||"+month+"||"+day);

      }

      编辑特别推荐:

      java函数参数传递

      Java语言的接口与类型安全

      java字母大小写转换问题


    展开全文
  • java的Date类的getYear(),getMonth()等函数都已经过时,可以使用Calendar 来替代。 SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd"); Calendar cal = Calendar.getInstance(); cal.setTime(tempDate)...

    java的Date类的getYear(),getMonth()等函数都已经过时,可以使用Calendar 来替代。

      SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd");  
      Calendar cal = Calendar.getInstance();  
      cal.setTime(tempDate);  
      System.out.println(ft.format(calender.getTime()));  
      System.out.println(calender.get(Calendar.YEAR));  
      System.out.println(calender.get(Calendar.MONTH));  

    还有
    Warning:(21, 26) java: java.net.URLEncoder中的encode(java.lang.String)已过时
    从 Java 2 platform v1.3 开始,java.net.URLEncoder的encode(String)改为 encode(String,String) 方法,第一个参数为需要编码的字符串,第二个参数指定编码。
    例如:

    URLEncoder.encode(info);
    URLEncoder.encode(info, “utf-8”);

    展开全文
  • Java的Date类与Calender类的比较

    千次阅读 2012-01-11 10:21:42
    在JDK1.0中,Date类是唯一一个代表时间类,但是由于Date类不便于实现国际化,所以从JDK1.1版本开始,推荐使用Calendar类进行时间和日期处理。这里简单介绍一下Date类的使用。 1、使用Date类代表当前系统时间 ...
    1、 Date
    

     

    JDK1.0中,Date类是唯一的一个代表时间的类,但是由于Date类不便于实现国际化,所以从JDK1.1版本开始,推荐使用Calendar类进行时间和日期处理。这里简单介绍一下Date类的使用。

    1、使用Date类代表当前系统时间

           Date d = new Date();

           System.out.println(d);

    使用Date类的默认构造方法创建出的对象就代表当前时间,由于Date类覆盖了toString方法,所以可以直接输出Date类型的对象,显示的结果如下:

                    Sun Mar 08 16:35:58 CST 2009

    在该格式中,Sun代表Sunday(周日)Mar代表March(三月)08代表8号,CST代表China Standard Time(中国标准时间,也就是北京时间(东八区))

         2、使用Date类代表指定的时间

                Date d1 = new Date(2009-1900,3-1,9);

                System.out.println(d1);

    使用带参数的构造方法,可以构造指定日期的Date类对象,Date类中年份的参数应该是实际需要代表的年份减去1900,实际需要代表的月份减去1以后的值。例如上面的示例代码代表就是200939号。

    实际代表具体的年月日时分秒的日期对象,和这个类似。

             3、获得Date对象中的信息

                                Date d2 = new Date();

                       //年份

                       int year = d2.getYear() + 1900;

                       //月份

                       int month = d2.getMonth() + 1;

                       //日期

                       int date = d2.getDate();

                       //小时

                       int hour = d2.getHours();

                       //分钟

                       int minute = d2.getMinutes();

                       //

                       int second = d2.getSeconds();

                       //星期几

                       int day = d2.getDay();

                       System.out.println("年份:" + year);

                       System.out.println("月份:" + month);

                       System.out.println("日期:" + date);

                       System.out.println("小时:" + hour);

                       System.out.println("分钟:" + minute);

                       System.out.println("秒:" + second);

                       System.out.println("星期:" + day);

     使用Date类中对应的get方法,可以获得Date类对象中相关的信息,需要注意的是使用getYear获得是Date对象中年份减去1900以后的值,所以需要显示对应的年份则需要在返回值的基础上加上1900,月份类似。在Date类中还提供了getDay方法,用于获得Date对象代表的时间是星期几,Date类规定周日是0,周一是1,周二是2,后续的依次类推。

    4Date对象和相对时间之间的互转

                      Date d3 = new Date(2009-1900,3-1,10);

                       long time = 1290876532190L;

                       //Date类的对象转换为相对时间

                       long t = d3.getTime();

                       System.out.println(t);

                       //将相对时间转换为Date类的对象

                       Date d4 = new Date(time);

                       System.out.println(d4);

             使用Date对象中的getTime方法,可以将Date类的对象转换为相对时间,使用Date类的构造方法,可以将相对时间转换为Date类的对象。经过转换以后,既方便了时间的计算,也使时间显示比较直观了。

     2、Calendar

    JDK1.1版本开始,在处理日期和时间时,系统推荐使用Calendar类进行实现。在设计上,Calendar类的功能要比Date类强大很多,而且在实现方式上也比Date类要复杂一些,下面就介绍一下Calendar类的使用。

    Calendar类是一个抽象类,在实际使用时实现特定的子类的对象,创建对象的过程对程序员来说是透明的,只需要使用getInstance方法创建即可。

    1、使用Calendar类代表当前时间

                       Calendar c = Calendar.getInstance();

    由于Calendar类是抽象类,且Calendar类的构造方法是protected的,所以无法使用Calendar类的构造方法来创建对象,API中提供了getInstance方法用来创建对象。

    使用该方法获得的Calendar对象就代表当前的系统时间,由于CalendartoString实现的没有Date类那么直观,所以直接输出Calendar类的对象意义不大。

    2、使用Calendar类代表指定的时间

                       Calendar c1 = Calendar.getInstance();

                       c1.set(2009, 3 - 1, 9);

    使用Calendar类代表特定的时间,需要首先创建一个Calendar的对象,然后再设定该对象中的年月日参数来完成。

    set方法的声明为:

             public final void set(int year,int month,int date)

    以上示例代码设置的时间为200939日,其参数的结构和Date类不一样。Calendar类中年份的数值直接书写,月份的值为实际的月份值减1,日期的值就是实际的日期值。

    如果只设定某个字段,例如日期的值,则可以使用如下set方法:

             public void set(int field,int value)

    在该方法中,参数field代表要设置的字段的类型,常见类型如下:

             Calendar.YEAR——年份

             Calendar.MONTH——月份

             Calendar.DATE——日期

             Calendar.DAY_OF_MONTH——日期,和上面的字段完全相同

             Calendar.HOUR——12小时制的小时数

             Calendar.HOUR_OF_DAY——24小时制的小时数

             Calendar.MINUTE——分钟

             Calendar.SECOND——秒

             Calendar.DAY_OF_WEEK——星期几

    后续的参数value代表,设置成的值。例如:

             c1.set(Calendar.DATE,10);

    该代码的作用是将c1对象代表的时间中日期设置为10号,其它所有的数值会被重新计算,例如星期几以及对应的相对时间数值等。

    3、获得Calendar类中的信息

                       Calendar c2 = Calendar.getInstance();

                       //年份

                       int year = c2.get(Calendar.YEAR);

                       //月份

                       int month = c2.get(Calendar.MONTH) + 1;

                       //日期

                       int date = c2.get(Calendar.DATE);

                       //小时

                       int hour = c2.get(Calendar.HOUR_OF_DAY);

                       //分钟

                       int minute = c2.get(Calendar.MINUTE);

                       //

                       int second = c2.get(Calendar.SECOND);

                       //星期几

                       int day = c2.get(Calendar.DAY_OF_WEEK);

                       System.out.println("年份:" + year);

                       System.out.println("月份:" + month);

                       System.out.println("日期:" + date);

                       System.out.println("小时:" + hour);

                       System.out.println("分钟:" + minute);

                       System.out.println("秒:" + second);

                       System.out.println("星期:" + day);

    使用Calendar类中的get方法可以获得Calendar对象中对应的信息,get方法的声明如下:

             public int get(int field)

    其中参数field代表需要获得的字段的值,字段说明和上面的set方法保持一致。需要说明的是,获得的月份为实际的月份值减1,获得的星期的值和Date类不一样。在Calendar类中,周日是1,周一是2,周二是3,依次类推。

    4、其它方法说明

    其实Calendar类中还提供了很多其它有用的方法,下面简单的介绍几个常见方法的使用。

    aadd方法

                       public abstract void add(int field,int amount)

    该方法的作用是在Calendar对象中的某个字段上增加或减少一定的数值,增加是amount的值为正,减少时amount的值为负。

             例如在计算一下当前时间100天以后的日期,代码如下:

                       Calendar c3 = Calendar.getInstance();

                       c3.add(Calendar.DATE, 100);

                       int year1 = c3.get(Calendar.YEAR);

                       //月份

                       int month1 = c3.get(Calendar.MONTH) + 1;

                       //日期

                       int date1 = c3.get(Calendar.DATE);

                       System.out.println(year1 + "" + month1 + "" + date1 + "");

    这里add方法是指在c3对象的Calendar.DATE,也就是日期字段上增加100,类内部会重新计算该日期对象中其它各字段的值,从而获得100天以后的日期,例如程序的输出结果可能为:

                       2009617

    bafter方法

                       public boolean after(Object when)

    该方法的作用是判断当前日期对象是否在when对象的后面,如果在when对象的后面则返回true,否则返回false。例如:

                       Calendar c4 = Calendar.getInstance();

                       c4.set(2009, 10 - 1, 10);

                       Calendar c5 = Calendar.getInstance();

                       c5.set(2010, 10 - 1, 10);

                       boolean b = c5.after(c4);

                       System.out.println(b);

    在该示例代码中对象c4代表的时间是20091010号,对象c5代表的时间是20101010号,则对象c5代表的日期在c4代表的日期之后,所以after方法的返回值是true

    另外一个类似的方法是before,该方法是判断当前日期对象是否位于另外一个日期对象之前。

                       cgetTime方法

                                         public final Date getTime()

    该方法的作用是将Calendar类型的对象转换为对应的Date类对象,两者代表相同的时间点。

    类似的方法是setTime,该方法的作用是将Date对象转换为对应的Calendar对象,该方法的声明如下:

             public final void setTime(Date date)

    转换的示例代码如下:

                      Date d = new Date();

                       Calendar c6 = Calendar.getInstance();

                       //Calendar类型的对象转换为Date对象

                       Date d1 = c6.getTime();

                       //Date类型的对象转换为Calendar对象

                       Calendar c7 = Calendar.getInstance();

                       c7.setTime(d);

             5Calendar对象和相对时间之间的互转

                                Calendar c8 = Calendar.getInstance();

                                long t = 1252785271098L;

                                //Calendar对象转换为相对时间

                                long t1 = c8.getTimeInMillis();

                                //将相对时间转换为Calendar对象

                                Calendar c9 = Calendar.getInstance();

                                c9.setTimeInMillis(t1);

    在转换时,使用Calendar类中的getTimeInMillis方法可以将Calendar对象转换为相对时间。在将相对时间转换为Calendar对象时,首先创建一个Calendar对象,然后再使用Calendar类的setTimeInMillis方法设置时间即可。

    3、应用示例

             下面以两个简单的示例介绍时间和日期处理的基本使用。

             1、计算两个日期之间相差的天数

    例如计算201041号和2009311号之间相差的天数,则可以使用时间和日期处理进行计算。

    该程序实现的原理为:首先代表两个特定的时间点,这里使用Calendar的对象进行代表,然后将两个时间点转换为对应的相对时间,求两个时间点相对时间的差值,然后除以1天的毫秒数(24小时X60分钟X60X1000毫秒)即可获得对应的天数。实现该示例的完整代码如下:

             import java.util.*;

    /**

     * 计算两个日期之间相差的天数

     */

    public class DateExample1 {

             public static void main(String[] args) {

                       //设置两个日期

                       //日期:2009311

                       Calendar c1 = Calendar.getInstance();

                       c1.set(2009, 3 - 1, 11);

                       //日期:201041

                       Calendar c2 = Calendar.getInstance();

                       c2.set(2010, 4 - 1, 1);

                       //转换为相对时间

                       long t1 = c1.getTimeInMillis();

                       long t2 = c2.getTimeInMillis();

                       //计算天数

                       long days = (t2 - t1)/(24 * 60 * 60 * 1000);

                       System.out.println(days);

             }

    }

             2、输出当前月的月历

    该示例的功能是输出当前系统时间所在月的日历,例如当前系统时间是2009310日,则输出20093月的日历。

    该程序实现的原理为:首先获得该月1号是星期几,然后获得该月的天数,最后使用流程控制实现按照日历的格式进行输出即可。即如果1号是星期一,则打印一个单位的空格,如果1号是星期二,则打印两个单位的空格,依次类推。打印完星期六的日期以后,进行换行。实现该示例的完整代码如下:

             import java.util.*;

    /**

     * 输出当前月的日历

     */

    public class DateExample2{

             public static void main(String[] args){

                       //获得当前时间

                       Calendar c = Calendar.getInstance();

                       //设置代表的日期为1

                       c.set(Calendar.DATE,1);

                       //获得1号是星期几

                       int start = c.get(Calendar.DAY_OF_WEEK);

                       //获得当前月的最大日期数

                       int maxDay = c.getActualMaximum(Calendar.DATE);   

                      

                       //输出标题

                       System.out.println("星期日 星期一 星期二 星期三 星期四 星期五   星期六");

    展开全文
  • import java.text.ParseException;...import java.util.Date;/** * 字符串转为日期前形式,直接用代码+注释了 * @author helloX007 */public class DateTest { public static void main(String[] args) ...
  • JAVA的Date类与Calendar类(常用方法)

    万次阅读 2016-03-08 16:04:08
    1.用java.util.Calender来实现  Calendar calendar=Calendar.getInstance();   calendar.setTime(new Date());  System.out.println(calendar.get(Calendar.DAY_OF_MONTH));//今天日期   cale
  • 参考文章1 参考文章2
  • Java Calendar 日历类的时间操作,这也许是 Java 环境下创建和管理日历及操作时间最简单一个方案了,示范代码也很简单。 演示了获取时间,日期时间累加和累减,以及日期时间比较。 原文地址:blog.csdn.net/...
  • java 使用Date类获取系统当前时间

    热门讨论 2010-06-21 15:16:14
    java 使用Date类获取系统当前时间 java 使用Date类获取系统当前时间 java 使用Date类获取系统当前时间
  • JavaDate类和Calendar类区别

    千次阅读 2019-05-08 21:20:12
    Date类:对于处理日期、时间,Java提供了Date类,此处的Date是指java.util包下的Date类;Date对象既包含日期,也包含时间。Date类从JDK1.0起就已经存在,经过不停的迭代更新,导致它的大部分构造器、方法都已经过时...
  • JavaDate类和Calendar类使用

    千次阅读 2019-04-11 15:21:52
    它还包含用于处理日期和时间类,例如Date类和Calendar类;下面将介绍Date类和Calendar类。 1、Date类 Date类对象表示当前日期和时间,并提供操纵日期和时间各组成部分方法。必须将Date对象转换为字符串,才能...
  • Java(Date类)

    万次阅读 2019-06-08 09:32:30
    Date类是在java.util包下的Date类。 2、Date类的构造器有: Date():分配Date对象并初始化此对象,以表示分配它的时间(精确到毫秒)。 Date(long date):分配 Date 对象并初始化此对象,以...
  • JavaDate类的用法

    2019-10-24 21:26:04
    1、java.text.DateFormat:是日期/时间格式化子类的抽象 2、作用:格式化(也就是日期 -> 文本)、解析(文本-> 日期) 3、成员方法: (1)String format(Date date) 按照指定模式,把Date日期,格式化为符合...
  • Java Date类

    2018-12-04 23:29:31
    java.util.Date类的子类java.sql.Date3. Date类的API不易于国际化,大部分被废弃了4.demo 1. java.util.Date类 表示特定瞬间,精确到毫秒 构造方法: ② Date( )使用Date类的无参数构造方法创建对象可以...
  • JavaDate类的使用

    万次阅读 2018-03-29 16:04:55
    因为javaDate是从1900年开始算,所以前面第一个参数只要填入从1900年后过了多少年就是你想要得到年份。 月需要减1,日可以直接插入。 这种方法用比较少,常用是第二种方法。2、 这种方法是将一个符合...
  • javaDate类

    千次阅读 2017-12-05 11:26:16
    //Date类对象用来表示时间和日期;...//Date类最多用途是获取系统当前日期和时间。 import java.util.Date; public class DateDemo { public static void main(String[] args) { Date date = new Date();//使用系
  • JAVA的Date类

    千次阅读 2020-11-17 20:44:08
    JAVA中如果想获取当前日期时间可以直接通过java.util.Date类来实现,此类常用操作如下表所示 例子: 获取当前日期时间 package DateDemo; import java.util.Date; public class Test { public static void ...
  • JavaDate类getTime()方法

    万次阅读 2018-10-08 11:39:55
    JavaDate类getTime()方法 1.getTime() /** Returns the number of milliseconds since January 1, 1970, 00:00:00 GMT represented by this Date object. 返回自从GMT 1970-01-01 00:00:00到此date对象上...
  • JAVAdate类的使用

    2019-04-28 13:44:54
    date类很多方法都弃用了或者过期;官方推荐使用calendar类 不过学习来看还是可以了解下: private static void test1() throws ParseException { Date d=new Date(); Date d2=new Date(); //以1970年...
  • java中,Date类与Calendar类同是对日期和时间进行操作类, Date是使用函数返回日期或时间,Calendar类是使用属性返回时间或日期 敢问,在实际一些应用中,这二者分别在什么环境下使用,或者说有什么 不同使用...
  • JavaDate类和Calendar类比较

    千次阅读 2018-10-23 17:32:47
    目前Java版本的Date类中已经逐步抛弃getDate()、getDay()的方法了,取而代之的是Calendar类的get()方法。所以在这边对Date类和Calendar类做一个总结。 Date类 这个类的来源非常的古老,从JDK1.0就有了,但是因为...
  • java的类库为我们提供了简单实用的Date类的操作。相信大家在网上也可以 找到很多很多关于此类的文章,我也是借鉴了一些文章根据自己的代码实践得到了一些结论。是对Date类最简单而且非常实用的利用。(1)首先我先来...
  • JavaDate类的常用方法

    千次阅读 2018-05-02 20:26:19
    Date类 表示特定瞬间,精确到毫秒(在java.util.Date包下)构造方法:public Date()表示分配它时间(精确到毫秒)。public Date(long date):创建一个日期对象,指定毫秒值 (需要将long 时间毫秒值转换成Date对象)...
  • javaDate类的练习

    千次阅读 2014-02-16 16:04:57
    package demo; import java.text.DateFormat; import java.text.ParseException; ...import java.text.SimpleDateFormat;...import java.util.Date;...import java.util.Locale;... * Date类  * 1 获取  * 1-1 获
  • JavaDate类的应用

    2014-12-04 10:31:06
    Date 实际上只是一个包裹, 它包含是一个长整型数据, 表示是从GMT(格林尼治标准时间)1970年, 1 月 1日00:00:00这一刻之前或者是之后经历毫秒数.  创建一个日期对象  让我们看一个使用系统当前日期...
  • Java时间类型 java.sql包下给出三个与数据库相关日期时间类型,分别是: Date:表示日期,只有年月日,...这三个都是java.util.Date的子类。 数据库类型与java中类型对应关系: DATEjava.sql.Date TI...
  • public static int minsBetween(Date date1, Date date2) { Calendar cal = Calendar.getInstance(); if (date1 == null || date2 == null) { return 0; } cal.setTime(date1); long time1 = cal....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,513
精华内容 7,005
关键字:

java的date类

java 订阅