精华内容
下载资源
问答
  • Java 时间格式

    2012-11-06 18:46:27
    import java.sql.Timestamp; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; public class DateUtil { public static void main(String[] args) { curren
    import java.sql.Timestamp;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    
    public class DateUtil {
    
    	
    	public static void main(String[] args) {
    		
    		currentTime();
    	}
    	
    	
    	/**
    	 * 获取当前时间格式化字符串
    	 */
    	public static String currentTime(){
    		//获取当前时间
    		java.util.Date currentTime = new java.util.Date();
    		//格式化类 SimpleDateFormat
    		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
    		//
    		String timeStr = sdf.format(currentTime);
    		//打印当前时间
    		System.out.println("currentTime:"+timeStr);
    		
    		return timeStr;
    		//要注意的:
    		
    		/**
    		 *  12时制和24时制的区别
    		 *  hh:mm:ss(12)  HH:mm:ss(24)
    		 */
    	}
    	
    	/**
    	 * String -> Date
    	 * @param str 要格式化的字符串
    	 * @param format  格式化的格式
    	 * @return
    	 */
    	public static java.util.Date StringToDate(String str,String format){
    		
    		if((str==null)||str.length()==0){
    			return null;
    		}
    		SimpleDateFormat sdf = new SimpleDateFormat(format);
    		try {
    			return sdf.parse(str);
    		} catch (ParseException e) {
    			e.printStackTrace();
    			return null;
    		}
    	}
    	
    	/**
    	 * Date -> String
    	 * @param date 要格式化的时间
    	 * @param format  格式化的格式字符串
    	 * @return
    	 */
    	public static String DateToString(java.util.Date date,String format){
    		SimpleDateFormat sdf = new SimpleDateFormat(format);
    		return sdf.format(date);
    	}
    	
    	/**
    	 * java.util.date  -> java.sql.date
    	 * @param udate
    	 * @return
    	 */
    	public static java.sql.Date UDateToSDate(java.util.Date udate){
    		
    		// java.util.date 和 java.sql.date的联系和区别
    		//    java.util.Date是在除了SQL语句的情况下面使用的。
    		//    java.sql.Date是针对SQL语句使用的,它只包含日期而没有时间部分
    		//    java.util.Date 是 java.sql.Date 的父类,前者是常用的表示时间的类,
    		//    我们通常格式化或者得到当前时间都是用他,后者之后在读写数据库的时候用他,
    		//    因为PreparedStament的setDate()的第2参数和ResultSet的getDate()方法的第2个参数都是java.sql.Date。
    		
    		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    		java.sql.Date sdate = new java.sql.Date(udate.getTime());
    		return sdate;
    	}
    	
    	/**
    	 * java.sql.date  -> java.util.date
    	 * @param sdate
    	 * @return
    	 */
    	public static java.util.Date SDateToUDate(java.sql.Date sdate){
    		return new java.util.Date(sdate.getTime());
    	}
    	
    	/**
    	 * java.util.Date -> java.sql.Timestamp
    	 * @param udate
    	 * @return
    	 */
    	public static Timestamp UDateToTimeStamp(java.util.Date udate){
    		return new java.sql.Timestamp(udate.getTime());
    	}
    	
    	/**
    	 * java.sql.Date -> java.sql.Timestamp
    	 * @param sdate
    	 * @return
    	 */
    	public static Timestamp SDateToTimeStamp(java.sql.Date sdate){
    		return new java.sql.Timestamp(sdate.getTime());
    	}
    	
    	/**
    	 * java.sql.Timestamp -> java.sql.Date
    	 * @param tdate
    	 * @return
    	 */
    	public static java.sql.Date TimeStampToSDate(Timestamp tdate){
    		return new java.sql.Date(tdate.getTime());
    	}
    	
    	
    	
    }
    

    展开全文
  • Java时间格式设置

    万次阅读 2018-08-24 11:43:56
    Java时间格式

    在开发中经常要设置一下时间的格式,我们看看怎么设置

    首先获取SimpleDateFormat对象并设置时间格式

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

    这个格式不用解释了,大家都明白

    获取当前时间:

    Date d = new Date();

    导包的时候要注意,注意导的是util的包还是sql的包

    然后把刚刚获取的时间进行格式化

    sf..format(d);

    完成

    展开全文
  • Java时间格式

    千次阅读 2011-07-07 17:23:39
    概要 不管你是处理财务交易还是计划着下一步的行动,你都要知道怎样在Java中建立,使用和显示日期。这需要你简单的查阅一下相应类的API参考:一个日期可以创建3个相关类的对象。这篇文章告诉你你想要知道的内容。(3...
    概要 
    不管你是处理财务交易还是计划着下一步的行动,你都要知道怎样在Java中建立,使用和显示日期。这需要你简单的查阅一下相应类的API参考:一个日期可以创建3个相关类的对象。这篇文章告诉你你想要知道的内容。(3,000字)
    作者:Robert Nielsen
    翻译:Cocia Lin

    Java统计从1970年1月1日起的毫秒的数量表示日期。也就是说,例如,1970年1月2日,是在1月1日后的86,400,000毫秒。同样的,1969年12月31日是在1970年1月1日前86,400,000毫秒。Java的Date类使用long类型纪录这些毫秒值.因为long是有符号整数,所以日期可以在1970年1月1日之前,也可以在这之后。Long类型表示的最大正值和最大负值可以轻松的表示290,000,000年的时间,这适合大多数人的时间要求。
    Date 类
    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);
    }
    }

    当我运行这个程序后,我得到972,568,255,150.快速确认一下这个数字,起码在一个合理的范围:它不到31年,这个数值相对1970年1月1日到我写这篇文章的时间来说,是合理的。计算机是这个毫秒值表示时间,人们可不愿意说" 我将在996,321,998,34见到你。"幸运的是,Java提供了一个转换Date对象到字符串的途径,表示成传统的形式。我们在下一节讨论DateFormat类,它直观的建立日期字符串。
    DateFormat类
    DateFormat类的一个目标是建立一个人们能够识别的字符串。然而,因为语言的差别,不是所有的人希望看到严格的相同格式的日期。法国人更喜欢看到"25 decembre 2000,",但是美国人习惯看到"December 25,2000."所以一个DateFormat的实例创建以后,这个对象包含了日期的显示格式的信息。假如使用用户电脑区域设置缺省的格式,你可以象下面那样,创建DateFormat对象,使用getDateInstance()方法:

    DateFormat df = DateFormat.getDateInstance();

    DateFormat类在java.text包中可以找到。
    转换成字符串
    你可以使用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);
    }
    }

    程序输出如下:

    (Default) Today is Nov 8, 2000
    (SHORT) Today is 11/8/00
    (MEDIUM) Today is Nov 8, 2000
    (LONG) Today is November 8, 2000
    (FULL) Today is Wednesday, November 8, 2000

    同样的程序,在我的电脑上使用缺省设置运行后,改变区域设置为瑞典,输出如下:

    (Default) Today is 2000-nov-08
    (SHORT) Today is 2000-11-08
    (MEDIUM) Today is 2000-nov-08
    (LONG) Today is den 8 november 2000
    (FULL) Today is den 8 november 2000

    从这里,你能看到,瑞典的月份不是大写的(虽然November还是november).还有,LONG和FULL版本在瑞典语中是一样的,但是美国英语却不同。另外,有趣的是,瑞典语单词的星期三,onsdag,没有包含在FULL日期里,英语却包括。
    注重你能够使用getDateInstance()方法改变DateFormat实例的语种;但是,在上面的例子中,是通过改变Windows98的控制面板的区域设置做到的。不同的地方的区域设置不同,结果就不同,这样有好处,也有不足,Java程序员应该了解这些。一个好处是Java程序员可以只写一行代码就可以显示日期,而且世界不同地区的电脑运行同样的程序会有不用的日期格式。 但是这也是一个缺点,当程序员希望显示同一种格式的时--这也有可取之处,举例来说,在程序中混合输出文本和日期,假如文本是英文,我们就不希望日期格式是其他的格式,象德文或是西班牙文。假如程序员依靠日期格式编程,日期格式将根据运行程序所在电脑的区域设置不用而不同。
    解析字符串
    通过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);

    在上一节中,你学习了转换Date对象到字符串。这里,你可以做同样的事情;但是首先,你需要将GregorianCalendar对象转换到Date。要做到这一点,你可以使用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 thisday = new 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()方法,你能够增加象年,月数,天数到日期对象中。要使用add()方法,你必须提供要增加的字段,要增加的数量。一些有用的字段是DATE, MONTH, YEAR, 和 WEEK_OF_YEAR。下面的程序使用add()方法计算未来80天的一个日期。在Jules的<环球80天>是一个重要的数字,使用这个程序可以计算Phileas Fogg从出发的那一天1872年10月2日后80天的日期:

    import java.util.*;
    import java.text.*;

    public class World {
    public static void main(String[] args) {
    GregorianCalendar worldTour = new GregorianCalendar(1872, Calendar.OCTOBER, 2);
    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);
    }
    }

    这个例子是想象的,但在一个日期上增加天数是一个普遍的操作:影碟可以租3天,图书馆可以借书21天,商店经常需要将购买的物品在30天内卖出。下面的程序演示了使用年计算:

    import java.util.*;
    import java.text.*;

    public class Mortgage {
    public static void main(String[] args) {
    GregorianCalendar mortgage = new GregorianCalendar(1997, Calendar.MAY, 18);
    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(2000, Calendar.JANUARY, 1);
    GregorianCalendar gc2 = gc1;
    GregorianCalendar gc3 = new GregorianCalendar(2000, Calendar.JANUARY, 1);
    //Three dates all equal to January 1, 2000

    gc1.add(Calendar.YEAR, 1);
    file://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,它没有被改变。
    计算复习日期
    在这节,你将看到一个依据现实世界的例子。这个具体的程序计算过去一个具体的日期。例如,你阅读这篇文章,你想要记住一个印象深刻的知识点。假如你没有照片一样的记忆力,你就要定期的复习这些新资料,这将帮助你记住它。关于复习系统,Kurt Hanks 和 Gerreld L. Pulsipher在他们的< Five Secrets to Personal ProdUCtivity个人能力的5个秘密>中有讨论,建议看过第一眼后马上回顾一下,然后是1天后,1个星期后,1个月后,3个月后,1年后。我的这篇文章,你要马上回顾一下,从现在算起,再就是明天,然后是1个星期,1个月,3个月,1年后。我们的程序将计算这些日期。
    这个程序非常有用的,它将是PIM(Personal Information Manager个人信息治理器)的一个组成部分,并将确定复习时间。在下面的程序中,getDates()方法对一个返回日期数组(复习日期)的电子软件很有用。另外,你可以返回单独的一个日期,使用getFirstDay(),getOneDay(),getOneWeek(),getOnMonth()和getOneYear().当时间范围超出这个PIM的ReviewDates的计算范围时ReviewDates类演示了怎样计算时间段。现在,你可以轻易的修改它用来处理你需要的时间段,象图书馆借书,录影带租赁和抵押计算。首先,ReviewDates类显示在下面:

    import java.util.*;
    import java.text.*;

    public class ReviewDates {
    private GregorianCalendar firstDay, oneDay, oneWeek, oneMonth, oneQuarter, oneYear;
    final int dateArraySize = 6;

    ReviewDates(GregorianCalendar gcDate) {
    int year = gcDate.get(GregorianCalendar.YEAR);
    int month = gcDate.get(GregorianCalendar.MONTH);
    int date = gcDate.get(GregorianCalendar.DATE);

    firstDay = new GregorianCalendar(year, month, date);
    oneDay = new GregorianCalendar(year, month, date);
    oneWeek = new GregorianCalendar(year, month, date);
    oneMonth = new GregorianCalendar(year, month, date);
    oneQuarter = new GregorianCalendar(year, month, date);
    oneYear = new GregorianCalendar(year, month, date);

    oneDay.add(GregorianCalendar.DATE, 1);
    oneWeek.add(GregorianCalendar.DATE, 7);
    oneMonth.add(GregorianCalendar.MONTH, 1);
    oneQuarter.add(GregorianCalendar.MONTH, 3);
    oneYear.add(GregorianCalendar.YEAR, 1);
    }

    ReviewDates() {
    this(new GregorianCalendar());
    }

    public void listDates() {
    DateFormat df = DateFormat.getDateInstance(DateFormat.LONG);
    Date startDate = firstDay.getTime();
    Date date1 = oneDay.getTime();
    Date date2 = oneWeek.getTime();
    Date date3 = oneMonth.getTime();
    Date date4 = oneQuarter.getTime();
    Date date5 = oneYear.getTime();

    String ss = df.format(startDate);
    String ss1 = df.format(date1);
    String ss2 = df.format(date2);
    String ss3 = df.format(date3);
    String ss4 = df.format(date4);
    String ss5 = df.format(date5);

    System.out.println("Start date is " + ss);
    System.out.println("Following review dates are:");
    System.out.println(ss1);
    System.out.println(ss2);
    System.out.println(ss3);
    System.out.println(ss4);
    System.out.println(ss5);
    System.out.println();
    }

    public GregorianCalendar[] getDates() {
    GregorianCalendar[] memoryDates = new GregorianCalendar[dateArraySize];
    memoryDates[0] = firstDay;
    memoryDates[1] = oneDay;
    memoryDates[2] = oneWeek;
    memoryDates[3] = oneMonth;
    memoryDates[4] = oneQuarter;
    memoryDates[5] = oneYear;
    return memoryDates;
    }

    public GregorianCalendar getFirstDay() {
    return this.firstDay;
    }

    public GregorianCalendar getOneDay() {
    return this.oneDay;
    }

    public GregorianCalendar getOneWeek() {
    return this.oneWeek;
    }

    public GregorianCalendar getOneMonth() {
    return this.oneMonth;
    }

    public GregorianCalendar getOneQuarter() {
    return this.oneQuarter;
    }

    public GregorianCalendar getOneYear() {
    return this.oneYear;
    }
    }

    下面是使用ReviewDates类列出复习日期的例子程序:

    import java.util.*;

    public class ShowDates {
    public static void main(String[] args) {
    ReviewDates rd = new ReviewDates();
    rd.listDates();

    GregorianCalendar gc = new GregorianCalendar(2001, Calendar.JANUARY, 15);
    ReviewDates jan15 = new ReviewDates(gc);
    jan15.listDates();
    }
    }

    总结
    这篇文章介绍了关于日期处理的3个重要的类:Date,DateFormat,GregorianCalendar.这些类让你创建日期,转换成字符串,和计算日期基本元素。处理Java中的日期问题,这篇文章只是冰山一角。可是,我在这里介绍的类和方法不仅仅是你学习高级技术的跳板,这些类和方法本身就可以处理很多通常的日期相关的任务
    展开全文
  • Java时间格式转换

    万次阅读 2019-02-25 18:53:02
    Java时间格式转换大全 2 3 import java.text.*; 4 import java.util.Calendar; 5 public class VeDate { 6 /** 7 * 获取现在时间 8 * 9 * @return 返回时间类型 yyyy-MM-dd HH:mm:ss 10 */ 11 public s....
    Java时间格式转换大全
      2 
      3 import java.text.*;
      4 import java.util.Calendar;
      5 public class VeDate {
      6 /**
      7    * 获取现在时间
      8    * 
      9    * @return 返回时间类型 yyyy-MM-dd HH:mm:ss
     10    */
     11 public static Date getNowDate() {
     12    Date currentTime = new Date();
     13    SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
     14    String dateString = formatter.format(currentTime);
     15    ParsePosition pos = new ParsePosition(8);
     16    Date currentTime_2 = formatter.parse(dateString, pos);
     17    return currentTime_2;
     18 }
     19 /**
     20    * 获取现在时间
     21    * 
     22    * @return返回短时间格式 yyyy-MM-dd
     23    */
     24 DateFormat format1 = new SimpleDateFormat("yyyy-MM-dd");         
     25 DateFormat format 2= new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");         
     26 Date date = null;    
     27 String str = null;                  
     28             
     29 // String转Date    
     30 str = "2007-1-18";          
     31 try {    
     32            date = format1.parse(str);   
     33            data = format2.parse(str); 
     34 } catch (ParseException e) {    
     35            e.printStackTrace();    
     36 }   
     37 /**
     38    * 获取现在时间
     39    * 
     40    * @return返回字符串格式 yyyy-MM-dd HH:mm:ss
     41    */
     42 public static String getStringDate() {
     43    Date currentTime = new Date();
     44    SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
     45    String dateString = formatter.format(currentTime);
     46    return dateString;
     47 }
     48 /**
     49    * 获取现在时间
     50    * 
     51    * @return 返回短时间字符串格式yyyy-MM-dd
     52    */
     53 public static String getStringDateShort() {
     54    Date currentTime = new Date();
     55    SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
     56    String dateString = formatter.format(currentTime);
     57    return dateString;
     58 }
     59 /**
     60    * 获取时间 小时:分;秒 HH:mm:ss
     61    * 
     62    * @return
     63    */
     64 public static String getTimeShort() {
     65    SimpleDateFormat formatter = new SimpleDateFormat("HH:mm:ss");
     66    Date currentTime = new Date();
     67    String dateString = formatter.format(currentTime);
     68    return dateString;
     69 }
     70 /**
     71    * 将长时间格式字符串转换为时间 yyyy-MM-dd HH:mm:ss
     72    * 
     73    * @param strDate
     74    * @return
     75    */
     76 public static Date strToDateLong(String strDate) {
     77    SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
     78    ParsePosition pos = new ParsePosition(0);
     79    Date strtodate = formatter.parse(strDate, pos);
     80    return strtodate;
     81 }
     82 /**
     83    * 将长时间格式时间转换为字符串 yyyy-MM-dd HH:mm:ss
     84    * 
     85    * @param dateDate
     86    * @return
     87    */
     88 public static String dateToStrLong(java.util.Date dateDate) {
     89    SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
     90    String dateString = formatter.format(dateDate);
     91    return dateString;
     92 }
     93 /**
     94    * 将短时间格式时间转换为字符串 yyyy-MM-dd
     95    * 
     96    * @param dateDate
     97    * @param k
     98    * @return
     99    */
    100 public static String dateToStr(java.util.Date dateDate) {
    101    SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
    102    String dateString = formatter.format(dateDate);
    103    return dateString;
    104 }
    105 /**
    106    * 将短时间格式字符串转换为时间 yyyy-MM-dd 
    107    * 
    108    * @param strDate
    109    * @return
    110    */
    111 public static Date strToDate(String strDate) {
    112    SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
    113    ParsePosition pos = new ParsePosition(0);
    114    Date strtodate = formatter.parse(strDate, pos);
    115    return strtodate;
    116 }
    117 /**
    118    * 得到现在时间
    119    * 
    120    * @return
    121    */
    122 public static Date getNow() {
    123    Date currentTime = new Date();
    124    return currentTime;
    125 }
    126 /**
    127    * 提取一个月中的最后一天
    128    * 
    129    * @param day
    130    * @return
    131    */
    132 public static Date getLastDate(long day) {
    133    Date date = new Date();
    134    long date_3_hm = date.getTime() - 3600000 * 34 * day;
    135    Date date_3_hm_date = new Date(date_3_hm);
    136    return date_3_hm_date;
    137 }
    138 /**
    139    * 得到现在时间
    140    * 
    141    * @return 字符串 yyyyMMdd HHmmss
    142    */
    143 public static String getStringToday() {
    144    Date currentTime = new Date();
    145    SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd HHmmss");
    146    String dateString = formatter.format(currentTime);
    147    return dateString;
    148 }
    149 /**
    150    * 得到现在小时
    151    */
    152 public static String getHour() {
    153    Date currentTime = new Date();
    154    SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    155    String dateString = formatter.format(currentTime);
    156    String hour;
    157    hour = dateString.substring(11, 13);
    158    return hour;
    159 }
    160 /**
    161    * 得到现在分钟
    162    * 
    163    * @return
    164    */
    165 public static String getTime() {
    166    Date currentTime = new Date();
    167    SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    168    String dateString = formatter.format(currentTime);
    169    String min;
    170    min = dateString.substring(14, 16);
    171    return min;
    172 }
    173 /**
    174    * 根据用户传入的时间表示格式,返回当前时间的格式 如果是yyyyMMdd,注意字母y不能大写。
    175    * 
    176    * @param sformat
    177    *             yyyyMMddhhmmss
    178    * @return
    179    */
    180 public static String getUserDate(String sformat) {
    181    Date currentTime = new Date();
    182    SimpleDateFormat formatter = new SimpleDateFormat(sformat);
    183    String dateString = formatter.format(currentTime);
    184    return dateString;
    185 }
    186 --------------------------------------------------------------------------------------------------------------------------------
    187 
    188 做成方法
    189 
    190 import java.util.*;
    191 import java.text.*;
    192 import java.util.Calendar;
    193 
    194 public class VeDate {
    195  /**
    196   * 获取现在时间
    197   * 
    198   * @return 返回时间类型 yyyy-MM-dd HH:mm:ss
    199   */
    200  public static Date getNowDate() {
    201   Date currentTime = new Date();
    202   SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    203   String dateString = formatter.format(currentTime);
    204   ParsePosition pos = new ParsePosition(8);
    205   Date currentTime_2 = formatter.parse(dateString, pos);
    206   return currentTime_2;
    207  }
    208 
    209  /**
    210   * 获取现在时间
    211   * 
    212   * @return返回短时间格式 yyyy-MM-dd
    213   */
    214  public static Date getNowDateShort() {
    215   Date currentTime = new Date();
    216   SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
    217   String dateString = formatter.format(currentTime);
    218   ParsePosition pos = new ParsePosition(8);
    219   Date currentTime_2 = formatter.parse(dateString, pos);
    220   return currentTime_2;
    221  }
    222 
    223  /**
    224   * 获取现在时间
    225   * 
    226   * @return返回字符串格式 yyyy-MM-dd HH:mm:ss
    227   */
    228  public static String getStringDate() {
    229   Date currentTime = new Date();
    230   SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    231   String dateString = formatter.format(currentTime);
    232   return dateString;
    233  }
    234 
    235  /**
    236   * 获取现在时间
    237   * 
    238   * @return 返回短时间字符串格式yyyy-MM-dd
    239   */
    240  public static String getStringDateShort() {
    241   Date currentTime = new Date();
    242   SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
    243   String dateString = formatter.format(currentTime);
    244   return dateString;
    245  }
    246 
    247  /**
    248   * 获取时间 小时:分;秒 HH:mm:ss
    249   * 
    250   * @return
    251   */
    252  public static String getTimeShort() {
    253   SimpleDateFormat formatter = new SimpleDateFormat("HH:mm:ss");
    254   Date currentTime = new Date();
    255   String dateString = formatter.format(currentTime);
    256   return dateString;
    257  }
    258 
    259  /**
    260   * 将长时间格式字符串转换为时间 yyyy-MM-dd HH:mm:ss
    261   * 
    262   * @param strDate
    263   * @return
    264   */
    265  public static Date strToDateLong(String strDate) {
    266   SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    267   ParsePosition pos = new ParsePosition(0);
    268   Date strtodate = formatter.parse(strDate, pos);
    269   return strtodate;
    270  }
    271 
    272  /**
    273   * 将长时间格式时间转换为字符串 yyyy-MM-dd HH:mm:ss
    274   * 
    275   * @param dateDate
    276   * @return
    277   */
    278  public static String dateToStrLong(java.util.Date dateDate) {
    279   SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    280   String dateString = formatter.format(dateDate);
    281   return dateString;
    282  }
    283 
    284  /**
    285   * 将短时间格式时间转换为字符串 yyyy-MM-dd
    286   * 
    287   * @param dateDate
    288   * @param k
    289   * @return
    290   */
    291  public static String dateToStr(java.util.Date dateDate) {
    292   SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
    293   String dateString = formatter.format(dateDate);
    294   return dateString;
    295  }
    296 
    297  /**
    298   * 将短时间格式字符串转换为时间 yyyy-MM-dd 
    299   * 
    300   * @param strDate
    301   * @return
    302   */
    303  public static Date strToDate(String strDate) {
    304   SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
    305   ParsePosition pos = new ParsePosition(0);
    306   Date strtodate = formatter.parse(strDate, pos);
    307   return strtodate;
    308  }
    309 
    310  /**
    311   * 得到现在时间
    312   * 
    313   * @return
    314   */
    315  public static Date getNow() {
    316   Date currentTime = new Date();
    317   return currentTime;
    318  }
    319 
    320  /**
    321   * 提取一个月中的最后一天
    322   * 
    323   * @param day
    324   * @return
    325   */
    326  public static Date getLastDate(long day) {
    327   Date date = new Date();
    328   long date_3_hm = date.getTime() - 3600000 * 34 * day;
    329   Date date_3_hm_date = new Date(date_3_hm);
    330   return date_3_hm_date;
    331  }
    332 
    333  /**
    334   * 得到现在时间
    335   * 
    336   * @return 字符串 yyyyMMdd HHmmss
    337   */
    338  public static String getStringToday() {
    339   Date currentTime = new Date();
    340   SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd HHmmss");
    341   String dateString = formatter.format(currentTime);
    342   return dateString;
    343  }
    344 
    345  /**
    346   * 得到现在小时
    347   */
    348  public static String getHour() {
    349   Date currentTime = new Date();
    350   SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    351   String dateString = formatter.format(currentTime);
    352   String hour;
    353   hour = dateString.substring(11, 13);
    354   return hour;
    355  }
    356 
    357  /**
    358   * 得到现在分钟
    359   * 
    360   * @return
    361   */
    362  public static String getTime() {
    363   Date currentTime = new Date();
    364   SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    365   String dateString = formatter.format(currentTime);
    366   String min;
    367   min = dateString.substring(14, 16);
    368   return min;
    369  }
    370 
    371  /**
    372   * 根据用户传入的时间表示格式,返回当前时间的格式 如果是yyyyMMdd,注意字母y不能大写。
    373   * 
    374   * @param sformat
    375   *            yyyyMMddhhmmss
    376   * @return
    377   */
    378  public static String getUserDate(String sformat) {
    379   Date currentTime = new Date();
    380   SimpleDateFormat formatter = new SimpleDateFormat(sformat);
    381   String dateString = formatter.format(currentTime);
    382   return dateString;
    383  }
    384 
    385  /**
    386   * 二个小时时间间的差值,必须保证二个时间都是"HH:MM"的格式,返回字符型的分钟
    387   */
    388  public static String getTwoHour(String st1, String st2) {
    389   String[] kk = null;
    390   String[] jj = null;
    391   kk = st1.split(":");
    392   jj = st2.split(":");
    393   if (Integer.parseInt(kk[0]) < Integer.parseInt(jj[0]))
    394    return "0";
    395   else {
    396    double y = Double.parseDouble(kk[0]) + Double.parseDouble(kk[1]) / 60;
    397    double u = Double.parseDouble(jj[0]) + Double.parseDouble(jj[1]) / 60;
    398    if ((y - u) > 0)
    399     return y - u + "";
    400    else
    401     return "0";
    402   }
    403  }
    404 
    405  /**
    406   * 得到二个日期间的间隔天数
    407   */
    408  public static String getTwoDay(String sj1, String sj2) {
    409   SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd");
    410   long day = 0;
    411   try {
    412    java.util.Date date = myFormatter.parse(sj1);
    413    java.util.Date mydate = myFormatter.parse(sj2);
    414    day = (date.getTime() - mydate.getTime()) / (24 * 60 * 60 * 1000);
    415   } catch (Exception e) {
    416    return "";
    417   }
    418   return day + "";
    419  }
    420 
    421  /**
    422   * 时间前推或后推分钟,其中JJ表示分钟.
    423   */
    424  public static String getPreTime(String sj1, String jj) {
    425   SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    426   String mydate1 = "";
    427   try {
    428    Date date1 = format.parse(sj1);
    429    long Time = (date1.getTime() / 1000) + Integer.parseInt(jj) * 60;
    430    date1.setTime(Time * 1000);
    431    mydate1 = format.format(date1);
    432   } catch (Exception e) {
    433   }
    434   return mydate1;
    435  }
    436 
    437  /**
    438   * 得到一个时间延后或前移几天的时间,nowdate为时间,delay为前移或后延的天数
    439   */
    440  public static String getNextDay(String nowdate, String delay) {
    441   try{
    442   SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
    443   String mdate = "";
    444   Date d = strToDate(nowdate);
    445   long myTime = (d.getTime() / 1000) + Integer.parseInt(delay) * 24 * 60 * 60;
    446   d.setTime(myTime * 1000);
    447   mdate = format.format(d);
    448   return mdate;
    449   }catch(Exception e){
    450    return "";
    451   }
    452  }
    453 
    454  /**
    455   * 判断是否润年
    456   * 
    457   * @param ddate
    458   * @return
    459   */
    460  public static boolean isLeapYear(String ddate) {
    461 
    462   /**
    463    * 详细设计: 1.被400整除是闰年,否则: 2.不能被4整除则不是闰年 3.能被4整除同时不能被100整除则是闰年
    464    * 3.能被4整除同时能被100整除则不是闰年
    465    */
    466   Date d = strToDate(ddate);
    467   GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
    468   gc.setTime(d);
    469   int year = gc.get(Calendar.YEAR);
    470   if ((year % 400) == 0)
    471    return true;
    472   else if ((year % 4) == 0) {
    473    if ((year % 100) == 0)
    474     return false;
    475    else
    476     return true;
    477   } else
    478    return false;
    479  }
    480 
    481  /**
    482   * 返回美国时间格式 26 Apr 2006
    483   * 
    484   * @param str
    485   * @return
    486   */
    487  public static String getEDate(String str) {
    488   SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
    489   ParsePosition pos = new ParsePosition(0);
    490   Date strtodate = formatter.parse(str, pos);
    491   String j = strtodate.toString();
    492   String[] k = j.split(" ");
    493   return k[2] + k[1].toUpperCase() + k[5].substring(2, 4);
    494  }
    495 
    496  /**
    497   * 获取一个月的最后一天
    498   * 
    499   * @param dat
    500   * @return
    501   */
    502  public static String getEndDateOfMonth(String dat) {// yyyy-MM-dd
    503   String str = dat.substring(0, 8);
    504   String month = dat.substring(5, 7);
    505   int mon = Integer.parseInt(month);
    506   if (mon == 1 || mon == 3 || mon == 5 || mon == 7 || mon == 8 || mon == 10 || mon == 12) {
    507    str += "31";
    508   } else if (mon == 4 || mon == 6 || mon == 9 || mon == 11) {
    509    str += "30";
    510   } else {
    511    if (isLeapYear(dat)) {
    512     str += "29";
    513    } else {
    514     str += "28";
    515    }
    516   }
    517   return str;
    518  }
    519 
    520  /**
    521   * 判断二个时间是否在同一个周
    522   * 
    523   * @param date1
    524   * @param date2
    525   * @return
    526   */
    527  public static boolean isSameWeekDates(Date date1, Date date2) {
    528   Calendar cal1 = Calendar.getInstance();
    529   Calendar cal2 = Calendar.getInstance();
    530   cal1.setTime(date1);
    531   cal2.setTime(date2);
    532   int subYear = cal1.get(Calendar.YEAR) - cal2.get(Calendar.YEAR);
    533   if (0 == subYear) {
    534    if (cal1.get(Calendar.WEEK_OF_YEAR) == cal2.get(Calendar.WEEK_OF_YEAR))
    535     return true;
    536   } else if (1 == subYear && 11 == cal2.get(Calendar.MONTH)) {
    537    // 如果12月的最后一周横跨来年第一周的话则最后一周即算做来年的第一周
    538    if (cal1.get(Calendar.WEEK_OF_YEAR) == cal2.get(Calendar.WEEK_OF_YEAR))
    539     return true;
    540   } else if (-1 == subYear && 11 == cal1.get(Calendar.MONTH)) {
    541    if (cal1.get(Calendar.WEEK_OF_YEAR) == cal2.get(Calendar.WEEK_OF_YEAR))
    542     return true;
    543   }
    544   return false;
    545  }
    546 
    547  /**
    548   * 产生周序列,即得到当前时间所在的年度是第几周
    549   * 
    550   * @return
    551   */
    552  public static String getSeqWeek() {
    553   Calendar c = Calendar.getInstance(Locale.CHINA);
    554   String week = Integer.toString(c.get(Calendar.WEEK_OF_YEAR));
    555   if (week.length() == 1)
    556    week = "0" + week;
    557   String year = Integer.toString(c.get(Calendar.YEAR));
    558   return year + week;
    559  }
    560 
    561  /**
    562   * 获得一个日期所在的周的星期几的日期,如要找出2002年2月3日所在周的星期一是几号
    563   * 
    564   * @param sdate
    565   * @param num
    566   * @return
    567   */
    568  public static String getWeek(String sdate, String num) {
    569   // 再转换为时间
    570   Date dd = VeDate.strToDate(sdate);
    571   Calendar c = Calendar.getInstance();
    572   c.setTime(dd);
    573   if (num.equals("1")) // 返回星期一所在的日期
    574    c.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
    575   else if (num.equals("2")) // 返回星期二所在的日期
    576    c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
    577   else if (num.equals("3")) // 返回星期三所在的日期
    578    c.set(Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY);
    579   else if (num.equals("4")) // 返回星期四所在的日期
    580    c.set(Calendar.DAY_OF_WEEK, Calendar.THURSDAY);
    581   else if (num.equals("5")) // 返回星期五所在的日期
    582    c.set(Calendar.DAY_OF_WEEK, Calendar.FRIDAY);
    583   else if (num.equals("6")) // 返回星期六所在的日期
    584    c.set(Calendar.DAY_OF_WEEK, Calendar.SATURDAY);
    585   else if (num.equals("0")) // 返回星期日所在的日期
    586    c.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
    587   return new SimpleDateFormat("yyyy-MM-dd").format(c.getTime());
    588  }
    589 
    590  /**
    591   * 根据一个日期,返回是星期几的字符串
    592   * 
    593   * @param sdate
    594   * @return
    595   */
    596  public static String getWeek(String sdate) {
    597   // 再转换为时间
    598   Date date = VeDate.strToDate(sdate);
    599   Calendar c = Calendar.getInstance();
    600   c.setTime(date);
    601   // int hour=c.get(Calendar.DAY_OF_WEEK);
    602   // hour中存的就是星期几了,其范围 1~7
    603   // 1=星期日 7=星期六,其他类推
    604   return new SimpleDateFormat("EEEE").format(c.getTime());
    605  }
    606  public static String getWeekStr(String sdate){
    607   String str = "";
    608   str = VeDate.getWeek(sdate);
    609   if("1".equals(str)){
    610    str = "星期日";
    611   }else if("2".equals(str)){
    612    str = "星期一";
    613   }else if("3".equals(str)){
    614    str = "星期二";
    615   }else if("4".equals(str)){
    616    str = "星期三";
    617   }else if("5".equals(str)){
    618    str = "星期四";
    619   }else if("6".equals(str)){
    620    str = "星期五";
    621   }else if("7".equals(str)){
    622    str = "星期六";
    623   }
    624   return str;
    625  }
    626 
    627  /**
    628   * 两个时间之间的天数
    629   * 
    630   * @param date1
    631   * @param date2
    632   * @return
    633   */
    634  public static long getDays(String date1, String date2) {
    635   if (date1 == null || date1.equals(""))
    636    return 0;
    637   if (date2 == null || date2.equals(""))
    638    return 0;
    639   // 转换为标准时间
    640   SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd");
    641   java.util.Date date = null;
    642   java.util.Date mydate = null;
    643   try {
    644    date = myFormatter.parse(date1);
    645    mydate = myFormatter.parse(date2);
    646   } catch (Exception e) {
    647   }
    648   long day = (date.getTime() - mydate.getTime()) / (24 * 60 * 60 * 1000);
    649   return day;
    650  }
    651 
    652  /**
    653   * 形成如下的日历 , 根据传入的一个时间返回一个结构 星期日 星期一 星期二 星期三 星期四 星期五 星期六 下面是当月的各个时间
    654   * 此函数返回该日历第一行星期日所在的日期
    655   * 
    656   * @param sdate
    657   * @return
    658   */
    659  public static String getNowMonth(String sdate) {
    660   // 取该时间所在月的一号
    661   sdate = sdate.substring(0, 8) + "01";
    662 
    663   // 得到这个月的1号是星期几
    664   Date date = VeDate.strToDate(sdate);
    665   Calendar c = Calendar.getInstance();
    666   c.setTime(date);
    667   int u = c.get(Calendar.DAY_OF_WEEK);
    668   String newday = VeDate.getNextDay(sdate, (1 - u) + "");
    669   return newday;
    670  }
    671 
    672  /**
    673   * 取得数据库主键 生成格式为yyyymmddhhmmss+k位随机数
    674   * 
    675   * @param k
    676   *            表示是取几位随机数,可以自己定
    677   */
    678 
    679  public static String getNo(int k) {
    680 
    681   return getUserDate("yyyyMMddhhmmss") + getRandom(k);
    682  }
    683 
    684  /**
    685   * 返回一个随机数
    686   * 
    687   * @param i
    688   * @return
    689   */
    690  public static String getRandom(int i) {
    691   Random jjj = new Random();
    692   // int suiJiShu = jjj.nextInt(9);
    693   if (i == 0)
    694    return "";
    695   String jj = "";
    696   for (int k = 0; k < i; k++) {
    697    jj = jj + jjj.nextInt(9);
    698   }
    699   return jj;
    700  }
    701 
    702  /**
    703   * 
    704   * @param args
    705   */
    706  public static boolean RightDate(String date) {
    707 
    708   SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
    709   ;
    710   if (date == null)
    711    return false;
    712   if (date.length() > 10) {
    713    sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
    714   } else {
    715    sdf = new SimpleDateFormat("yyyy-MM-dd");
    716   }
    717   try {
    718    sdf.parse(date);
    719   } catch (ParseException pe) {
    720    return false;
    721   }
    722   return true;
    723  }
    724 
    725  /***************************************************************************
    726   * //nd=1表示返回的值中包含年度 //yf=1表示返回的值中包含月份 //rq=1表示返回的值中包含日期 //format表示返回的格式 1
    727   * 以年月日中文返回 2 以横线-返回 // 3 以斜线/返回 4 以缩写不带其它符号形式返回 // 5 以点号.返回
    728   **************************************************************************/
    729  public static String getStringDateMonth(String sdate, String nd, String yf, String rq, String format) {
    730   Date currentTime = new Date();
    731   SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
    732   String dateString = formatter.format(currentTime);
    733   String s_nd = dateString.substring(0, 4); // 年份
    734   String s_yf = dateString.substring(5, 7); // 月份
    735   String s_rq = dateString.substring(8, 10); // 日期
    736   String sreturn = "";
    737   roc.util.MyChar mc = new roc.util.MyChar();
    738   if (sdate == null || sdate.equals("") || !mc.Isdate(sdate)) { // 处理空值情况
    739    if (nd.equals("1")) {
    740     sreturn = s_nd;
    741     // 处理间隔符
    742     if (format.equals("1"))
    743      sreturn = sreturn + "年";
    744     else if (format.equals("2"))
    745      sreturn = sreturn + "-";
    746     else if (format.equals("3"))
    747      sreturn = sreturn + "/";
    748     else if (format.equals("5"))
    749      sreturn = sreturn + ".";
    750    }
    751    // 处理月份
    752    if (yf.equals("1")) {
    753     sreturn = sreturn + s_yf;
    754     if (format.equals("1"))
    755      sreturn = sreturn + "月";
    756     else if (format.equals("2"))
    757      sreturn = sreturn + "-";
    758     else if (format.equals("3"))
    759      sreturn = sreturn + "/";
    760     else if (format.equals("5"))
    761      sreturn = sreturn + ".";
    762    }
    763    // 处理日期
    764    if (rq.equals("1")) {
    765     sreturn = sreturn + s_rq;
    766     if (format.equals("1"))
    767      sreturn = sreturn + "日";
    768    }
    769   } else {
    770    // 不是空值,也是一个合法的日期值,则先将其转换为标准的时间格式
    771    sdate = roc.util.RocDate.getOKDate(sdate);
    772    s_nd = sdate.substring(0, 4); // 年份
    773    s_yf = sdate.substring(5, 7); // 月份
    774    s_rq = sdate.substring(8, 10); // 日期
    775    if (nd.equals("1")) {
    776     sreturn = s_nd;
    777     // 处理间隔符
    778     if (format.equals("1"))
    779      sreturn = sreturn + "年";
    780     else if (format.equals("2"))
    781      sreturn = sreturn + "-";
    782     else if (format.equals("3"))
    783      sreturn = sreturn + "/";
    784     else if (format.equals("5"))
    785      sreturn = sreturn + ".";
    786    }
    787    // 处理月份
    788    if (yf.equals("1")) {
    789     sreturn = sreturn + s_yf;
    790     if (format.equals("1"))
    791      sreturn = sreturn + "月";
    792     else if (format.equals("2"))
    793      sreturn = sreturn + "-";
    794     else if (format.equals("3"))
    795      sreturn = sreturn + "/";
    796     else if (format.equals("5"))
    797      sreturn = sreturn + ".";
    798    }
    799    // 处理日期
    800    if (rq.equals("1")) {
    801     sreturn = sreturn + s_rq;
    802     if (format.equals("1"))
    803      sreturn = sreturn + "日";
    804    }
    805   }
    806   return sreturn;
    807  }
    808 
    809  public static String getNextMonthDay(String sdate, int m) {
    810   sdate = getOKDate(sdate);
    811   int year = Integer.parseInt(sdate.substring(0, 4));
    812   int month = Integer.parseInt(sdate.substring(5, 7));
    813   month = month + m;
    814   if (month < 0) {
    815    month = month + 12;
    816    year = year - 1;
    817   } else if (month > 12) {
    818    month = month - 12;
    819    year = year + 1;
    820   }
    821   String smonth = "";
    822   if (month < 10)
    823    smonth = "0" + month;
    824   else
    825    smonth = "" + month;
    826   return year + "-" + smonth + "-10";
    827  }
    828 
    829  public static String getOKDate(String sdate) {
    830   if (sdate == null || sdate.equals(""))
    831    return getStringDateShort();
    832 
    833   if (!VeStr.Isdate(sdate)) {
    834    sdate = getStringDateShort();
    835   }
    836   // 将“/”转换为“-”
    837   sdate = VeStr.Replace(sdate, "/", "-");
    838   // 如果只有8位长度,则要进行转换
    839   if (sdate.length() == 8)
    840    sdate = sdate.substring(0, 4) + "-" + sdate.substring(4, 6) + "-" + sdate.substring(6, 8);
    841   SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
    842   ParsePosition pos = new ParsePosition(0);
    843   Date strtodate = formatter.parse(sdate, pos);
    844   String dateString = formatter.format(strtodate);
    845   return dateString;
    846  }
    847 
    848  public static void main(String[] args) throws Exception {
    849   try {
    850    //System.out.print(Integer.valueOf(getTwoDay("2006-11-03 12:22:10", "2006-11-02 11:22:09")));
    851   } catch (Exception e) {
    852    throw new Exception();
    853   }
    854   //System.out.println("sss");
    855  }

     

    展开全文
  • java 时间格式

    2017-09-01 10:57:04
    java 时间格式
  • java时间格式化与格式

    2018-01-04 19:17:21
    java时间格式 ;  yyyy-MM-dd HH:mm:ss 数据库时间格式: YYYY-MM-DD HH24:MI:SS
  • Java时间格式转换大全

    千次阅读 2019-02-18 15:50:46
    Java时间格式转换大全 import java.text.*; import java.util.Calendar; public class VeDate { /** * 获取现在时间 * * @return 返回时间类型 yyyy-MM-dd HH:mm:ss */ public static Date getNowDate() { ...
  • Java 时间格式转换大全

    千次阅读 2018-10-15 17:30:38
    Java时间格式转换大全 import java.text.*; import java.util.Calendar; public class VeDate { /** * 获取现在时间 * * @return 返回时间类型 yyyy-MM-dd HH:mm:ss */ public static Date getNowDate() { ...
  • Java时间格式大全

    千次阅读 2014-04-14 19:48:06
    又收藏到一个好的java时间格式大全,这个是做成了类的 又收藏到一个好的java时间格式大全,这个是做成了类的  转自:http://www.busfly.cn/post/java_string_date_time_class_all.html
  • Java时间格式对照表

    2017-04-16 18:29:12
    参考:Java时间格式对照表 JAVA 8:健壮、易用的时间/日期API JAVA处理日期(Date)时间(Time)以及相关类的介绍 字母 日期或时间元素 表示 示例 G Era 标志符 T
  • JAVA时间格式化处理

    2017-05-25 17:15:46
    JAVA时间格式化处理 日期格式化 import java.util.Date; import java.text.SimpleDateFormat; class dayTime { public static void main(String args[]) { Date nowTime=new Date(); System.out....
  • JAVA时间格式转换大全

    2016-02-19 13:02:00
    Java时间格式转换大全 importjava.text.*; importjava.util.Calendar; publicclassVeDate { /** * 获取现在时间 * * @return 返回时间类型 yyyy-MM-dd HH:mm:ss */ publicstaticDate getNowDate() { D.....
  • java时间格式化处理处理

    千次阅读 2018-04-28 10:42:01
    原文链接:https://blog.csdn.net/wyp164/article/details/1625980JAVA时间格式化处理日期格式化import java.util.Date; import java.text.SimpleDateFormat; class dayTime { public static void main(String ...
  • java时间格式化转换

    千次阅读 2013-11-19 17:11:53
    java时间格式化转换,String转Date,Date转String
  • DateFormat java时间格式化 import java.util.Date; import java.text.DateFormat; /** * 格式化时间类 * DateFormat.FULL = 0 * DateFormat.DEFAULT = 2 * DateFormat.LONG = 1 * DateFormat.MEDIUM = 2
  • java 时间格式转码,处理时间后多个0问题 代码方法: /** * 日期格式字符串转换 * @param date_str 字符串日期 * @return String */ public static String date2TimeStamp(String date_str){ ...
  • JAVA时间格式处理

    千次阅读 2010-08-24 11:29:00
    JAVA时间格式化处理 日期格式化 import java.util.Date; import java.text.SimpleDateFormat; class dayTime { public static void main(String args[]) { ...
  • Java 时间格式转换

    2016-04-03 15:36:50
    貌似java里面么有ToString()的时间类型格式,想格式时间还得自己写个函数 public class SimpleDateFormatDemo { public static String dateToString(Date d,String format){ return new SimpleDateFormat(format)...
  • Java时间格式化的注意事项 今天在尝试将格式不明的时间转换为标准的时间格式时,遇到了几个问题,在此记录下 【需求:将格式不明的时间转换为标准格式,如将“HH:mm yyyy/MM/dd”、“HH:mm:ss”、“yyyy/MM/dd”...
  • java时间格式转换

    2018-04-14 11:49:23
    今天做任务时候,数据库里面时间是timestamp时间戳格式,但是接口接收到的时间是年月日格式,然后查了资料,用simepledateformat类来做格式化。一个是把年月日通过parse解析成时间戳,一个是通过format时间戳格式化...
  • Java时间格式表示

    热门讨论 2020-02-28 19:22:16
    1. 日历时间格式 1.1 Date 时期类[逐渐淘汰] 获取当前系统时间 大部分构造方法已经过时 构造方法 Date(); 创建一个Date,对应当前时间,精度在毫秒值 Date(long date); 根据时间戳毫秒数,创建对应的Date...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,598
精华内容 6,239
关键字:

java时间格式

java 订阅