Java日期格式转换 Date转String、String转Date

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

发表评论

表情：
评论列表 （有 0 条评论，463人围观）

还没有评论，来说两句吧...

相关阅读