Java常用日期封装

最新推荐文章于 2024-10-11 17:30:36 发布
最新推荐文章于 2024-10-11 17:30:36 发布
阅读量108 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteye_13897/article/details/82298773
版权
/**
  * all rights reserved by zhanqiong, 2005
  */
package com.koubei.util;
 
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
 
/**
  * @author chen
  *
  */
public class DateUtil {
   
   /**
    * 日
    */
   public final static int INTERVAL_DAY = 1 ;
   /**
    * 周
    */
   public final static int INTERVAL_WEEK = 2 ;
   /**
    * 月
    */
   public final static int INTERVAL_MONTH = 3 ;
   /**
    * 年
    */
   public final static int INTERVAL_YEAR = 4 ;
   /**
    * 小时
    */
   public final static int INTERVAL_HOUR = 5 ;
   /**
    * 分钟
    */
   public final static int INTERVAL_MINUTE = 6 ;
   /**
    * 秒
    */
   public final static int INTERVAL_SECOND = 7 ; 
   
   /**
    * date = 1901-01-01
    */
   public final static Date tempDate= new Date( new Long( "-2177481952000" ));;
 
   /**
    * 测试是否是当天
    *
    * @param date - 某一日期
    * @return true-今天, false-不是
    */
   @SuppressWarnings ( "deprecation" )
   public static boolean isToday(Date date) {
     Date now = new Date();
     boolean result = true ;
     result &= date.getYear()==now.getYear();
     result &= date.getMonth()==now.getMonth();
     result &= date.getDate()==now.getDate();
     return result;
   }
 
   /**
    * 两个日期相减，取天数
    *
    * @param date1
    * @param date2
    * @return
    */
   public static long DaysBetween(Date date1, Date date2) {
     if (date2 == null )
       date2 = new Date();
     long day = (date2.getTime() - date1.getTime()) / ( 24 * 60 * 60 * 1000 );
     return day;
   }
 
   /**
    * 比较两个日期 if date1<=date2 return true
    *
    * @param date1
    * @param date2
    * @return
    */
   public static boolean compareDate(String date1, String date2) {
     SimpleDateFormat format = new SimpleDateFormat( "yyyy-MM-dd" );
     try {
       Date d1 = format.parse(date1);
       Date d2 = format.parse(date2);
       return !d1.after(d2);
     } catch (ParseException e) {
       e.printStackTrace();
       return false ;
     }
   }
 
   /**
    * 字符型转换成日期型
    *
    * @param date
    * @param dateFormat
    * @return
    */
   public static Date dateFormat(String date, String dateFormat) {
     if (date == null )
       return null ;
     SimpleDateFormat format = new SimpleDateFormat(dateFormat);
     if (date != null ) {
       try {
         return format.parse(date);
       } catch (Exception ex) {
       }
     }
     return null ;
   }
 
     
   /**
    * 使用默认格式 yyyy-MM-dd HH:mm:ss
    * @author Robin Chang
    * @param date
    * @return
    */
   public static Date dateFormat(String date)
   {
     return dateFormat(date, "yyyy-MM-dd HH:mm:ss" );
   }
 
   /**
    * 日期型转换成字符串
    *
    * @param date
    * @param dateFormat
    * @return
    */
   public static String dateFormat(Date date, String dateFormat) {
     if (date == null )
       return "" ;
     SimpleDateFormat format = new SimpleDateFormat(dateFormat);
     if (date != null ) {
       return format.format(date);
     }
     return "" ;
   }
   
   /**
      * 由于生日增加保密属性，现决定1900为保密对应值，如果遇到1900的年份，则隐掉年份
      *
      * @param date
      * @param dateFormat
      * @return 不保密显示1981-12-01保密则显示`12-01
      */
     public static String birthdayFormat(Date date) {
         if (date == null )
             return "" ;
         SimpleDateFormat format = null ;
         if (date.before(tempDate)) {
             format = new SimpleDateFormat( "MM-dd" );
         } else {
             format = new SimpleDateFormat( "yyyy-MM-dd" );      
         }
         if (date != null ) {
             return format.format(date);
         }
         return "" ;
     }
     
   /**
    * 使用默认格式 yyyy-MM-dd HH:mm:ss
    * @param date
    * @return
    */
   public static String dateFormat(Date date)
   {
     return dateFormat(date, "yyyy-MM-dd HH:mm:ss" );
   }
   
 
   public static boolean isExpiredDay(Date date1) {
     long day = ( new Date().getTime() - date1.getTime()) / ( 24 * 60 * 60 * 1000 );
     if (day >= 1 )
       return true ;
     else
       return false ;
   }
 
   public static Date getYesterday() {
     Date date = new Date();
     long time = (date.getTime() / 1000 ) - 60 * 60 * 24 ;
     date.setTime(time * 1000 );
     SimpleDateFormat format = new SimpleDateFormat( "yyyy-MM-dd" );
     try {
       date = format.parse(format.format(date));
     } catch (Exception ex) {
       System.out.println(ex.getMessage());
     }
     return date;
   }
 
   public static Date getWeekAgo() {
     Date date = new Date();
     long time = (date.getTime() / 1000 ) - 7 * 60 * 60 * 24 ;
     date.setTime(time * 1000 );
     SimpleDateFormat format = new SimpleDateFormat( "yyyy-MM-dd" );
     try {
       date = format.parse(format.format(date));
     } catch (Exception ex) {
       System.out.println(ex.getMessage());
     }
     return date;
   }
 
   public static String getDaysAgo( int interval) {
     Date date = new Date();
     long time = (date.getTime() / 1000 ) - interval * 60 * 60 * 24 ;
     date.setTime(time * 1000 );
     SimpleDateFormat format = new SimpleDateFormat( "yyyy-MM-dd" );
     try {
       return format.format(date);
     } catch (Exception ex) {
       System.out.println(ex.getMessage());
     }
     return "" ;
   }
 
   public static Date getTomorrow() {
     Date date = new Date();
     long time = (date.getTime() / 1000 ) + 60 * 60 * 24 ;
     date.setTime(time * 1000 );
     SimpleDateFormat format = new SimpleDateFormat( "yyyy-MM-dd" );
     try {
       date = format.parse(format.format(date));
     } catch (Exception ex) {
       System.out.println(ex.getMessage());
     }
     return date;
   }
 
   
 
   public static Date getBeforeDate(String range) {
     Calendar today = Calendar.getInstance();
     if ( "week" .equalsIgnoreCase(range))
       today.add(Calendar.WEEK_OF_MONTH, - 1 );
     else if ( "month" .equalsIgnoreCase(range))
       today.add(Calendar.MONTH, - 1 );
     else
       today.clear();
     return today.getTime();
   }
 
   public static Date getThisWeekStartTime() {
     Calendar today = Calendar.getInstance();
     today.set(Calendar.DAY_OF_WEEK, today.getFirstDayOfWeek());
     Calendar weekFirstDay = Calendar.getInstance();
     weekFirstDay.clear();
     weekFirstDay.set(Calendar.YEAR, today.get(Calendar.YEAR));
     weekFirstDay.set(Calendar.MONTH, today.get(Calendar.MONTH));
     weekFirstDay.set(Calendar.DATE, today.get(Calendar.DATE));
     return weekFirstDay.getTime();
   }
 
   public static String getToday(String format) {
     String result = "" ;
     try {
       Date today = new Date();
       SimpleDateFormat simpleFormat = new SimpleDateFormat(format);
       result = simpleFormat.format(today);
     } catch (Exception e) {
     }
     return result;
   }
 
   public static Date getStartDay( int year, int month) {
     Calendar today = Calendar.getInstance();
     today.clear();
     today.set(Calendar.YEAR, year);
     today.set(Calendar.MONTH, month - 1 );
     today.set(Calendar.DAY_OF_MONTH, 1 );
     return today.getTime();
   }
 
   public static List<Integer> getBeforeYearList( int before) {
     Calendar today = Calendar.getInstance();
     int theYear = today.get(Calendar.YEAR);
     List<Integer> list = new ArrayList<Integer>();
     for ( int i = before; i >= 0 ; i--)
       list.add(theYear - i);
 
     return list;
   }
   
   /**
    * 增加时间
    * @param interval [INTERVAL_DAY,INTERVAL_WEEK,INTERVAL_MONTH,INTERVAL_YEAR,INTERVAL_HOUR,INTERVAL_MINUTE]
    * @param date
    * @param n 可以为负数
    * @return
    */
   public static Date dateAdd( int interval,Date date, int n)
   {
     long time = (date.getTime() / 1000 ); //单位秒
     switch (interval)
     {
       case INTERVAL_DAY:
         time = time + n * 86400 ; //60 * 60 * 24;
         break ;
       case INTERVAL_WEEK:
         time = time + n * 604800 ; //60 * 60 * 24 * 7;
         break ;
       case INTERVAL_MONTH:
         time = time + n * 2678400 ; //60 * 60 * 24 * 31;
         break ;
       case INTERVAL_YEAR:
         time = time + n * 31536000 ; //60 * 60 * 24 * 365;
         break ;
       case INTERVAL_HOUR:
         time = time + n * 3600 ; //60 * 60 ;
         break ;
       case INTERVAL_MINUTE:
         time = time + n * 60 ;
         break ;
       case INTERVAL_SECOND:
         time = time + n;
         break ;
       default :
     }
     
     Date result = new Date();
     result.setTime(time * 1000 );
     return result;
   }
   
   /**
    * 计算两个时间间隔
    * @param interval [INTERVAL_DAY,INTERVAL_WEEK,INTERVAL_MONTH,INTERVAL_YEAR,INTERVAL_HOUR,INTERVAL_MINUTE]
    * @param begin
    * @param end
    * @return
    */
   public static int dateDiff( int interval,Date begin,Date end)
   {
     long beginTime = (begin.getTime() / 1000 ); //单位：秒
     long endTime = (end.getTime() / 1000 ); //单位: 秒
     long tmp = 0 ;
     if (endTime == beginTime)
     {
       return 0 ;
     }
 
     //确定endTime 大于 beginTime 结束时间秒数 大于 开始时间秒数
     if (endTime < beginTime)
     {
       tmp = beginTime;
       beginTime = endTime;
       endTime = tmp;
     }
     
     long intervalTime = endTime - beginTime;
     long result = 0 ;
     switch (interval)
     {
       case INTERVAL_DAY:
         result = intervalTime / 86400 ; //60 * 60 * 24;
         break ;
       case INTERVAL_WEEK:
         result = intervalTime / 604800 ; //60 * 60 * 24 * 7;
         break ;
       case INTERVAL_MONTH:
         result = intervalTime / 2678400 ; //60 * 60 * 24 * 31;
         break ;
       case INTERVAL_YEAR:
         result = intervalTime / 31536000 ; //60 * 60 * 24 * 365;
         break ;
       case INTERVAL_HOUR:
         result = intervalTime / 3600 ; //60 * 60 ;
         break ;
       case INTERVAL_MINUTE:
         result = intervalTime / 60 ;
         break ;
       case INTERVAL_SECOND:
         result = intervalTime / 1 ;
         break ;
       default :
     }  
     
     //做过交换
     if (tmp > 0 )
     {
       result = 0 - result;
     }
     return ( int ) result;
   }
   
   /**
    * 当前年份
    * @return
    */
   public static int getTodayYear()
   {
     int yyyy = Integer.parseInt(dateFormat( new Date(), "yyyy" ));
     return yyyy;
   }
     
   public static Date getNow()
   {
     return new Date();
   }
   
   /**
    * 把日期格式为rss格式兼容的字符串
    * @param date
    * @return
    */
   public static String dateFormatRss(Date date)
   {
     if (date != null )
     {
       return dateFormat(date, "E, d MMM yyyy H:mm:ss" ) + " GMT" ;
     }
     return "" ;
   }
   
   /**
    * 判断当前日期是否在两个日期之间
    * @param startDate 开始时间
    * @param endDate　结束时间
    * @return　
    */
   public static boolean betweenStartDateAndEndDate(Date startDate,Date endDate){
     boolean bool= false ;
     Date curDate= new Date();
     if (curDate.after(startDate) && curDate.before(DateUtil.dateAdd( INTERVAL_DAY ,endDate, 1 )) ){
       bool= true ;
     }
     return bool;
     
   }
   
   /**
    * 判断当前时间是否在在两个时间之间
    * @param startDate 开始时间
    * @param endDate　结束时间
    * @return　
    */
   public static boolean nowDateBetweenStartDateAndEndDate(Date startDate,Date endDate){
     boolean bool= false ;
     Date curDate= new Date();
     if (curDate.after(startDate) && curDate.before(endDate)){
       bool= true ;
     }
     return bool;
   }
   
   /**
    * 判断当前时间是否在date之后
    * @param date
    * @return　
    */
   public static boolean nowDateAfterDate(Date date){
     boolean bool= false ;
     Date curDate= new Date();
     if (curDate.after(date)){
       bool= true ;
     }
     return bool;
   }
   
   
   /**
    * 判断二个日期相隔的天数,结束时间为null时，，取当前时间
    * @param startDate 开始时间
    * @param endDate　结束时间
    * @return　
    */
   public static int getBetweenTodaysStartDateAndEndDate(Date startDate,Date endDate){
     int betweentoday = 0 ;
     if (startDate== null ){
       return betweentoday;
     }
     if (endDate== null ){
       Calendar calendar = Calendar.getInstance();
       String year = new Integer(calendar.get(Calendar.YEAR)).toString();
       String month = new Integer((calendar.get(calendar.MONTH)+ 1 )).toString();
       String day =  new Integer(calendar.get(calendar.DAY_OF_MONTH)).toString();
       String strtodaytime = year+ "-" +month+ "-" +day;
       DateFormat  formatter= new SimpleDateFormat( "yyyy-MM-dd" );  
       try {
         endDate = formatter.parse(strtodaytime);
       } catch (ParseException e) {
         //TODO Auto-generated catch block
         e.printStackTrace();
       }
     }
     
     if (endDate.after(startDate)){
       betweentoday =  ( int )((endDate.getTime() -startDate.getTime())/ 86400000 );
     } else {
       betweentoday =  ( int )((startDate.getTime() -endDate.getTime())/ 86400000 );
     }
     return betweentoday;
   }
      /**  
       *   取得指定长度日期时间字符串{不含格式}  
           @param   format   时间格式由常量决定  
           8: 　YYMMDDHH            8位  
         10:　YYMMDDHHmm          10位  
       12:　YYMMDDHHmmss        12位  
       14:　YYYYMMDDHHmmss      14位  
       15:　YYMMDDHHmmssxxx     15位   (最后的xxx   是毫秒)
 
       */
   public   static  String  getTime( int  format){  
         StringBuffer   cTime= new   StringBuffer( 10 );  
         Calendar   time=Calendar.getInstance();  
         int   miltime=time.get(Calendar.MILLISECOND);  
         int   second=time.get(Calendar.SECOND);  
         int   minute=time.get(Calendar.MINUTE);  
         int   hour=time.get(Calendar.HOUR_OF_DAY);  
         int   day   =time.get(Calendar.DAY_OF_MONTH);  
         int   month=time.get(Calendar.MONTH)+ 1 ;  
         int   year   =time.get(Calendar.YEAR);  
         if (format!= 14 ){  
                 if (year>= 2000 )   year=year- 2000 ;  
                 else   year=year- 1900 ;  
         }  
         if (format>= 2 ){  
                 if (format== 14 )   cTime.append(year);  
                 else         cTime.append(getFormatTime(year, 2 ));  
         }  
         if (format>= 4 )  
                 cTime.append(getFormatTime(month, 2 ));  
         if (format>= 6 )  
                 cTime.append(getFormatTime(day, 2 ));  
         if (format>= 8 )  
                 cTime.append(getFormatTime(hour, 2 ));  
         if (format>= 10 )  
                 cTime.append(getFormatTime(minute, 2 ));  
         if (format>= 12 )  
                 cTime.append(getFormatTime(second, 2 ));  
         if (format>= 15 )  
                 cTime.append(getFormatTime(miltime, 3 ));  
         return   cTime.toString();  
   }  
     /**  
       *　产生任意位的字符串  
       *   @param   time   要转换格式的时间  
       *   @param   format　转换的格式  
       *   @return　String   转换的时间  
       */
   private  static  String  getFormatTime( int  time, int   format){  
           StringBuffer   numm= new   StringBuffer();  
           int   length=String.valueOf(time).length();
           if (format<length)   return   null ;
           for ( int   i= 0   ;i<format-length   ;i++){  
                   numm.append( "0" );  
           }  
           numm.append(time);  
           return   numm.toString().trim();  
    }  
   
   
   /**
    * 根据生日去用户年龄
    * @param birthday
    * @return int
    * @exception
    * @author     豆皮
    * @Date       Apr 24, 2008
    */
   public static int getUserAge(Date birthday){
      if (birthday == null ) return 0 ;
      Calendar cal = Calendar.getInstance();
        if (cal.before(birthday)) {
          return 0 ;
      }
      int yearNow = cal.get(Calendar.YEAR);
      cal.setTime(birthday); // 给时间赋值
      int yearBirth = cal.get(Calendar.YEAR);
      return yearNow - yearBirth;
   }
 
     /**
      * 将int型时间(1970年至今的秒数)转换成Date型时间
      * @param unixTime 1970年至今的秒数
      * @return
      * @author     郑卿
      */
     public static Date getDateByUnixTime( int unixTime){
         return new Date(unixTime*1000L);
     }
     
     /**
      * 将Date型时间转换成int型时间(1970年至今的秒数)
      * @param unixTime 1970年至今的秒数
      * @return
      * @author     郑卿
      */
     public static int getUnixTimeByDate(Date date){
         return ( int )(date.getTime()/ 1000 );
     }
 
   
   public static void main(String[] args) {
       Date date1 =dateFormat( "1981-01-01 00:00:00" );
       Date date2 =dateFormat( "1900-12-31 00:00:00" );
       System.out.println(birthdayFormat(date1));
         System.out.println(birthdayFormat(date2));
   }
   public static Date getNextDay(Date date) {
     long time = (date.getTime() / 1000 ) + 60 * 60 * 24 ;
     date.setTime(time * 1000 );
     SimpleDateFormat format = new SimpleDateFormat( "yyyy-MM-dd" );
     try {
       date = format.parse(format.format(date));
     } catch (Exception ex) {
       System.out.println(ex.getMessage());
     }
     return date;
 
   }
 
   /**
    * @param date
    * @return
    * 复制新Date，不改变参数
    */
   public static Date nextDay(Date date) {
     Date newDate = (Date) date.clone();
     long time = (newDate.getTime() / 1000 ) + 60 * 60 * 24 ;
     newDate.setTime(time * 1000 );
     SimpleDateFormat format = new SimpleDateFormat( "yyyy-MM-dd" );
     try {
       newDate = format.parse(format.format(newDate));
     } catch (Exception ex) {
       System.out.println(ex.getMessage());
     }
     return newDate;
 
   }
 
   @SuppressWarnings ( "unused" )
   public static Date getNowTime() {
     SimpleDateFormat format = new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" );
     Date date = new Date();
     String dateStr = dateFormat(date);
     try {
       date = format.parse(dateStr);
     } catch (ParseException e) {
       e.printStackTrace();
     }
     return date;
   }
 
   public static Date getTomorrow(Date date1) {
 
     // 创建当前时间对象
     Calendar now = Calendar.getInstance();
     now.setTime(date1);
     // 日期[+1]day
     now.add(Calendar.DATE, 1 );
     return now.getTime();
   }
 
   public static Date getWeekAgo(Date date) {
     Date newDate = (Date) date.clone();
     long time = (newDate.getTime() / 1000 ) - 60 * 60 * 24 * 7 ;
     newDate.setTime(time * 1000 );
     SimpleDateFormat format = new SimpleDateFormat( "yyyy-MM-dd" );
     try {
       newDate = format.parse(format.format(newDate));
     } catch (Exception ex) {
       System.out.println(ex.getMessage());
     }
     return newDate;
   }
 
   public static Date getDatebyTime(Date date, int n) {
     String str = DateUtil.dateFormat(date, "yyyy-MM-dd" );
     String[] strs = str.split( "-" );
     int month = Integer.parseInt(strs[ 1 ]);
     int monthnow = (month + n) % 12 ;
     int year = Integer.parseInt(strs[ 0 ]) + (month + n) / 12 ;
     str = String.valueOf(year) + "-" + String.valueOf(monthnow) + "-"
         + strs[ 2 ];
     return DateUtil.dateFormat(str, "yyyy-MM-dd" );
   }
 
   /**
    * @param date
    * @return
    * 复制新Date，不改变参数
    */
   public static Date yesterday(Date date) {
     Date newDate = (Date) date.clone();
     long time = (newDate.getTime() / 1000 ) - 60 * 60 * 24 ;
     newDate.setTime(time * 1000 );
     SimpleDateFormat format = new SimpleDateFormat( "yyyy-MM-dd" );
     try {
       newDate = format.parse(format.format(newDate));
     } catch (Exception ex) {
       System.out.println(ex.getMessage());
     }
     return newDate;
   }
 
   public static Date getYesterday(Date date) {
     long time = (date.getTime() / 1000 ) - 60 * 60 * 24 ;
     date.setTime(time * 1000 );
     SimpleDateFormat format = new SimpleDateFormat( "yyyy-MM-dd" );
     try {
       date = format.parse(format.format(date));
     } catch (Exception ex) {
       System.out.println(ex.getMessage());
     }
     return date;
   }
 
   private static SimpleDateFormat format = null ;
   @SuppressWarnings ( "unused" )
   public static String getStringNowTime() {
     format = new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" );
     Date date = new Date();
     String dateStr = dateFormat(date);
 
     return dateStr;
   }
   
   
   /**
      * 指定时间的秒数
      * 指定时间零点的秒数加指定天数的秒数
      * @param time 时间
      * @param range  天
      * @return
      */
     public static long getSpecifyTimeSec( long time, int range){
       Date date       = new Date((time* 1000 +( 23 -Calendar.ZONE_OFFSET)* 3600000 )/ 86400000 * 86400000 -( 23 -Calendar.ZONE_OFFSET)* 3600000 );  
       long zeroTime     = date.getTime()/ 1000 ;
       long specifyTime  = range * 24 * 3600 ;
       return (zeroTime+specifyTime);
     }
     
     /**
      * 将int型时间(1970年至今的秒数)转换成指定格式的时间
      *
      * @param unixTime 1970年至今的秒数
      * @param dateFormat 时间格式
      * @return
      * @author  sky
      */
     public static String formatDateByUnixTime( long unixTime, String dateFormat){
         return dateFormat( new Date(unixTime* 1000 ), dateFormat);
     }
   
}
iteye_13897
关注
专栏目录
java-常用类之封装类
qq_46027570的博客
07-24 1593
java-常用类之封装类
项目中常用java常用封装类
10-23
总之，Java中的封装是提高代码质量的重要手段。通过封装，我们可以将复杂的功能分解为简单的模块，降低代码的耦合度，使代码更易于理解和维护。在项目实践中，不断积累并复用这些封装好的类和方法，能够显著提升开发...
JS根据指定字符串日期获取月份
奈&何.
04-26 1279
指定日期不为空，返回指定日期的月份，指定日期为空，则返回当前日期的月份 function ConverToDate(date) { var result = ['一', '二', '三', '四', '五', '六', '七', '八', '九', '十', '十一', '十二']; var m = new Date().getMonth() if (date != '' && date != null) { m = new Date(date)..
DateUtil 日期操作工具类
weixin_33736048的博客
11-15 225
为什么80%的码农都做不了架构师？>>> ...
java常用日期封装
jjjackjack的博客
02-14 380
1，再当前日期上进行累加 /** * 当前日期加减多少天 */ public static String getNowDateString(int day){ return LocalDate.now().plusDays(day).format(DateTimeFormatter.ofPattern("yyyy-MM-dd")); } /** * 当前日期加减多少月 */ public static Dat
java 日期类封装_java 常用工具封装日期类
weixin_42328834的博客
02-24 383
java 常用工具封装日期类常用的日期类进行封装，避免以后在调用日期的时候在此写该方法那么会导致项目臃肿。返回当前星期的Map集合/** 返回参数所在星期的七天，如传入'2021-06-02'星期四，则返回所在星期周一到周日的Map* @param date* @return Map* */public static HashMapString,Date getWeekDates(Date dat...
java 日期类封装_java中日期类封装Dateutils
weixin_29912855的博客
02-24 172
常用日期类封装，使用maven管理项目，引入org.apache.commonscommons-lang3封装类如下：import org.apache.commons.lang3.time.DateFormatUtils;import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Date;...
Java中日期和时间的处理及工具类封装
qq_68512683的博客
07-28 251
Java中日期和时间的处理及工具类封装
java常用json工具类封装，自定义日期、数据格式
qq_45132989的博客
07-08 577
/ 如果json中有新增的字段并且是实体类类中不存在的，不报错。自定义json配置，主要为了更好的应对业务，可根据自己的需求进行封装定义格式。//若POJO对象的属性值为null，序列化时不进行显示。//解决json参数和pojo参数数量不一致导致报错问题。// 禁止date类型转换为时间戳。// 设置date类型转换格式。二、json配置中心。
Java项目开发中常见的日期操作工具类封装
boo程序员的博客
04-01 1207
一、Java项目开发中常见的日期操作工具类封装 代码如下（示例）： import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.sql.Time; import java.text.SimpleDateFormat; import java.time.LocalDate; import java.time.LocalDateTime; import java.time.ZoneId; import java.time.form
java 封装 方法_java常用封装方法
weixin_42135773的博客
02-15 299
public Map getDateByStr(String str,String startDate,String endTime){Map map = new HashMap();if("3".equals(str)){map.put("beginTime", DateUtil.getAnyDate(-7));map.put("endTime", DateUtil.getAnyDate(0))...
封装java常用工具的类
11-28
常见的加密算法如AES、DES、RSA等可以在Java中实现，用于数据加密和解密。 6. **时间类**：Java 8引入了新的日期和时间API（java.time包），它提供了更直观、更易于使用的日期、时间、时区处理功能，替代了之前的...
Java中对日期的常用处理（转）
05-27
本文将基于标题“Java中对日期的常用处理（转）”来深入探讨Java中的日期处理，结合`DateUtil.java`这个文件名，我们可以推测这是一个包含日期处理工具类的源代码文件。 首先，Java中处理日期的最基础类是`java....
Java常用类库StringBuffer，Runtime，日期操作类等类库总结
08-25
Calendar类是Java中一个高级的日期类，提供了对日期和时间的高级操作。DateFormat类是Java中一个日期格式化类，提供了对日期和时间的格式化操作。 日期操作类常用的方法有： * getDate()：取得当前日期 * getTime...
Java数据封装树形结构代码实例
08-25
Date类是Java中定义的一种类，它用于存储日期和时间。Date类提供了多种方法，例如getYear、getMonth、getDay等。Date类常用于存储实体类中的日期和时间字段。在本文中，createtime和lastmodifytime字段使用了Date类...
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1415
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
Springboot api http并发测试请求
nsa65223的专栏
10-11 241
【代码】Springboot api http并发测试请求。
Netty 相比原生IO模型的优势
lssffy的博客
10-09 638
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
Backend - Java 基础
最新发布
是萝卜干呀的博客
10-11 811
知识量决定了未来能走多远
Java常用操作方法封装与代码测试指南
资源摘要信息:"该资源是一个封装了常用Java操作方法的代码库，名为opslabJutil-master。它的核心目的是为了提高开发效率，通过预置并不断完善的代码模块，减少重复编码工作，从而节约开发时间。该代码库的维护者鼓励...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值