时间日期工具类

package com.fengtu.sparktest.utils

import java.text.{ParseException, SimpleDateFormat}
import java.util.{Calendar, Date}

import scala.collection.mutable.ArrayBuffer
import scala.util.matching.Regex

object DateTimeUtil extends Serializable {

    def main(args: Array[String]): Unit = {

//        val halfYearDay = DateTimeUtil.getDaysApartDate("yyyyMMdd","20210606",-180)
//        println(halfYearDay)
        //println(transformDateFormat("2021-03-08","yyyy-MM-dd","yyyyMMdd"))
        //println(getLastTwoWeekMS("2021-03-08","yyyy-MM-dd"))
        //println(getLastMonthMonday("2021-03-10","yyyy-MM-dd"))
        //println(getMinBeforeAfter("2021-03-10 17:2:52","yyyy-MM-dd HH:mm:ss",5))
//
//        println(getPreMonthFirstDay("20201102","yyyyMMdd"))
//        println(getPreMonthLastDay("20201102","yyyyMMdd"))
        //如8号跑数，则取上个月1号到上个月月底的班次信息数据；如22号跑数，则取上个月15号到本月15号的班次信息数据。
//        println(getMinBeforeAfter("2021-06-07 03:10:00","yyyy-MM-dd HH:mm:ss",18))

//        println(transformDateFormat("20210615","20210620","yyyyMMdd","yyyyMMdd"))
 //       println(getConvertFormatDate("2020-09-17 17:12:52","yyyy-MM-dd HH:mm:ss","yyyy-MM-dd"))

        println(DateTimeUtil.getDateInterval("2021-05-24","2021-06-10","yyyy-MM-dd","yyyy-MM-dd"))

       // println(judgeWeekDay("20210615","yyyyMMdd"))

    }

    /**
      * 解析2H2M时间数据到数值
      * @param ft_time
      * @return
      */
    def parseFtTime(ft_time: String): Int = {

        if (StringUtils.isEmpty(ft_time)) {
            return 0
        } else {
            var hour = 0
            var min = 0

            try {
                val patternH = new Regex("([0-9]*)H.*")
                val patternM = new Regex("([0-9]*)M")
                if (patternH.findFirstIn(ft_time) != None) {
                    hour = patternH.findAllMatchIn(ft_time).map(_.group(1)).toList.mkString("").toInt
                }
                if (patternM.findFirstIn(ft_time) != None) {
                    min = patternM.findAllMatchIn(ft_time).map(_.group(1)).toList.mkString("").toInt
                }
            } catch {
                case e: Exception => e.printStackTrace()
            }

            hour * 60 + min
        }
    }

    /**
      * 判断当前日期是星期几
      */

    def judgeWeekDay(inc_day: String, srcDateFormat: String): Int = {

        val cal = Calendar.getInstance()
        val sdf = new SimpleDateFormat(srcDateFormat)

        var dayForWeek = 0
        try {
            cal.setTime(sdf.parse(inc_day))
            val w = cal.get(Calendar.DAY_OF_WEEK) - 1
            if (cal.get(Calendar.DAY_OF_WEEK) == 1) {
                dayForWeek = 7
            } else {
                dayForWeek = cal.get(Calendar.DAY_OF_WEEK) - 1
            }
        } catch {
            case e: Exception => e.printStackTrace()
        }

        dayForWeek

    }



    /**
      * 循环日期区间
      */

    def getDateInterval(inc_day1:String,inc_day2:String,srcDateFormat:String,targetDateFormat:String):ArrayBuffer[String]={

        val sdf = new SimpleDateFormat(srcDateFormat)
        val sdfNew = new SimpleDateFormat(targetDateFormat)
        val buffer = new ArrayBuffer[String]()

        try {
            val d1 = sdf.parse(inc_day1)
            val d2 = sdf.parse(inc_day2)
            var tmp = d1
            val dd = Calendar.getInstance()

            dd.setTime(d1)
            while (tmp.getTime < d2.getTime) {
                tmp = dd.getTime()
                buffer.append(sdfNew.format(tmp))
                dd.add(Calendar.DAY_OF_MONTH, 1)
            }
        } catch {
            case e: Exception => e.printStackTrace()
        }

        buffer
    }






    /**
      * 转换日期格式
      */

    def transformDateFormat(srcDate:String,srcDateFormat:String,targetDateFormat:String):String={

        val sdf = new SimpleDateFormat(srcDateFormat)
        val sdfNew = new SimpleDateFormat(targetDateFormat)

        val inputDate: Date = sdf.parse(srcDate)
        sdfNew.format(inputDate)

    }


    /**
      * 获取上一个月第一天和最后一天
      */
    def getMonthBeginEnd(srcDate:String,srcDateFormat:String):(String,String) ={

        val sdf = new SimpleDateFormat(srcDateFormat)
        val inputDate: Date = sdf.parse(srcDate)
        val calendar = Calendar.getInstance()
        calendar.setTime(inputDate)
        calendar.set(Calendar.MONTH, calendar.get(Calendar.MONTH) - 1)
        calendar.set(Calendar.DAY_OF_MONTH, 1)
        val beginDay = sdf.format(calendar.getTime())
        calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH))
        val endDay = sdf.format(calendar.getTime())
        (beginDay,endDay)
    }

    /**
      * 获取上一个月第15天和本月15天
      */
    def getMonthMidBeginEnd(srcDate:String,srcDateFormat:String):(String,String) ={

        val sdf = new SimpleDateFormat(srcDateFormat)
        val inputDate: Date = sdf.parse(srcDate)
        val calendar = Calendar.getInstance()
        calendar.setTime(inputDate)
        calendar.set(Calendar.MONTH, calendar.get(Calendar.MONTH) - 1)
        calendar.set(Calendar.DAY_OF_MONTH, 15)
        val beginDay = sdf.format(calendar.getTime())
        calendar.set(Calendar.MONTH,calendar.get(Calendar.MONTH) + 1)
        val endDay = sdf.format(calendar.getTime())
        (beginDay,endDay)
    }






    /**
      * 获取往后两周的周一和周日
      */

    def getLastTwoWeekMS(srcDate:String,srcDateFormat:String) ={
        val sdf = new SimpleDateFormat(srcDateFormat)
        val inputDate: Date = sdf.parse(srcDate)
        val calendar = Calendar.getInstance()

        calendar.setFirstDayOfWeek(Calendar.MONDAY)
        calendar.setTime(inputDate)
        calendar.add(Calendar.DAY_OF_YEAR, 14)

        var dayWeek = calendar.get(Calendar.DAY_OF_WEEK)
        if(dayWeek==1){
            dayWeek = 8
        }


        calendar.add(Calendar.DATE, calendar.getFirstDayOfWeek() - dayWeek)
        val firstDay = sdf.format(calendar.getTime())

        calendar.add(Calendar.DATE, 4 +calendar.getFirstDayOfWeek())
        val weekEnd = sdf.format(calendar.getTime)


        (firstDay,weekEnd)

    }








    /**
      * 获取后一个月的第二周周一
      */
    def getLastMonthMonday(srcDate:String,srcDateFormat:String): String ={

        val sdf = new SimpleDateFormat(srcDateFormat)
        val inputDate: Date = sdf.parse(srcDate)
        val calendar = Calendar.getInstance()
        calendar.setTime(inputDate)
        calendar.add(Calendar.MONTH, 1)
        calendar.set(Calendar.WEEK_OF_MONTH, 2)
        calendar.set(Calendar.DAY_OF_WEEK, 2);//本周第一天，以星期日开始
        val firstDay = sdf.format(calendar.getTime())
        firstDay

    }





    /**
      * 计算前几分钟的时间格式
      */

    def getMinBeforeAfter(srcDate:String,srcDateFormat:String,intervel:Int):String = {

        var minBeforeAfter = srcDate
        try{
            val sdf = new SimpleDateFormat(srcDateFormat)
            val inputDate: Date = sdf.parse(srcDate)
            val calendar = Calendar.getInstance()
            calendar.setTime(inputDate)
            calendar.add(Calendar.MINUTE, intervel)
            minBeforeAfter = sdf.format(calendar.getTime())
        }catch {
            case e:Exception => println(e.printStackTrace())
        }
        minBeforeAfter
    }



    /**
      * @note 获取前一个月的第一天
      * @param srcDate  源日期
      * @param srcDateFormat   源日期格式
      * @return
      */
    def getPreMonthFirstDay(srcDate:String,srcDateFormat:String):String={

        val sdf = new SimpleDateFormat(srcDateFormat)
        val inputDate: Date = sdf.parse(srcDate)
        //获取前一个月第一天
        val calendar = Calendar.getInstance()
        calendar.setTime(inputDate)
        calendar.add(Calendar.MONTH, -1)
        calendar.set(Calendar.DAY_OF_MONTH,1)
        val firstDay = sdf.format(calendar.getTime())
        firstDay
    }

    /**
      * @note 获取前一个月的最后一天
      * @param srcDate  源日期
      * @param srcDateFormat   源日期格式
      * @return
      */
    def getPreMonthLastDay(srcDate:String,srcDateFormat:String):String={
        val sdf = new SimpleDateFormat(srcDateFormat)
        val inputDate: Date = sdf.parse(srcDate)

        //获取前一个月最后一天
        val calendar = Calendar.getInstance()
        calendar.setTime(inputDate)
        calendar.set(Calendar.DAY_OF_MONTH, 0)
        val lastDay = sdf.format(calendar.getTime())

        lastDay

    }


    /**
      * @note 将日期转换为指定的日期格式
      * @param srcDate  源日期
      * @param srcDateFormat   源日期格式
      * @param destDateFormat   目标日期格式
      * @return
      */
    def getConvertFormatDate(srcDate: String, srcDateFormat: String, destDateFormat: String): String = {
        val date = new SimpleDateFormat(srcDateFormat).parse(srcDate)
        val destDate = new SimpleDateFormat(destDateFormat).format(date)
        destDate
    }

    /**
      * 获得两个字符串日期中所有日期的字符格式集合
      * @param startDateStr
      * @param endDateStr
      * @return
      */
    def getBetweenDatesStr(startDateStr: String, endDateStr: String): ArrayBuffer[String] = {
        val sdf = new SimpleDateFormat("yyyy-MM-dd")
        val dateListStr = new ArrayBuffer[String]
        try {
            val startDate = sdf.parse(startDateStr)
            val endDate = sdf.parse(endDateStr)
            val dateList = getBetweenDates(startDate, endDate)
            for (date <- dateList)
                dateListStr += sdf.format(date)
        } catch {
            case e: ParseException => println(">>>Date Convert Exception..." + e)
        }
        dateListStr
    }

    def getBetweenDatesStr(startDateStr: String, endDateStr: String, dateFormat:String): ArrayBuffer[String] = {
        val sdf = new SimpleDateFormat(dateFormat)
        val dateListStr = new ArrayBuffer[String]
        try {
            val startDate: Date = sdf.parse(startDateStr)
            val endDate: Date = sdf.parse(endDateStr)
            val dateList = getBetweenDates(startDate, endDate)
            for (date <- dateList)
                dateListStr += sdf.format(date)
        } catch {
            case e: ParseException => println(">>>Date Convert Exception..." + e)
        }
        dateListStr
    }


    /**
      * 获得两个日期之间的所有日期列表
      * @param start
      * @param end
      * @return
      */
    def getBetweenDates(start: Date, end: Date): ArrayBuffer[Date] = {
        val result = new ArrayBuffer[Date]
        val tempStart = Calendar.getInstance
        tempStart.setTime(start)
        tempStart.add(Calendar.DAY_OF_YEAR, 1)
        val tempEnd = Calendar.getInstance
        tempEnd.setTime(end)
        while (tempStart.before(tempEnd)) {
            result += tempStart.getTime
            tempStart.add(Calendar.DAY_OF_YEAR, 1)
        }
        result
    }

    /**
      * 获取本机日历日期
      * @param delta
      * @return
      */
    def dateDelta(delta: Int): String = {
        dateDelta(delta, "-")
    }

    /**
      * 获取本机日历日期
      * @param delta
      * @return
      */
    def dateDelta(delta: Int, separator: String): String = {
        val sdf = new SimpleDateFormat("yyyy" + separator + "MM" + separator + "dd")
        val cal = Calendar.getInstance()
        cal.add(Calendar.DATE, delta)
        val date = sdf.format(cal.getTime)
        date
    }

    /**
      * 获取本机当前系统时间并转换为指定日期格式
      * @param  format 日期格式
      * @return
      */
    def getCurrentSystemTime(format: String): String ={
        val simpleDateFormat = new SimpleDateFormat(format)
        val calendar = Calendar.getInstance()
        calendar.add(Calendar.DATE, 0)
        val dateTime = simpleDateFormat.format(calendar.getTime)
        dateTime
    }


    /**
      * @note   获取距离指定日期相隔days天的的日期：
      * @param inputDateStr 指定日期
      * @param days          相隔天数 正数表示在之后n天，负数表示在之前n天
      * @param dateFormat   日期格式(eg：yyyy-MM-dd, yyyy/MM/dd)
      * @return
      **/
    def getDaysApartDate(dateFormat: String, inputDateStr: String, days: Integer): String = {
        val simpleDateFormat = new SimpleDateFormat(dateFormat)
        val inputDate: Date = simpleDateFormat.parse(inputDateStr)
        val calendar = Calendar.getInstance
        calendar.setTime(inputDate)
        calendar.add(Calendar.DAY_OF_YEAR, days)
        val date = calendar.getTime
        val dateStr = simpleDateFormat.format(date).trim
        dateStr
    }

    /**
      * 时间字符串转换成毫秒值
      * @param time
      * @return
      */
    @throws[ParseException]
    def timeToLong(time: String, format: String): Long = {
        val sf = new SimpleDateFormat(format)
        sf.parse(time).getTime
    }

    /**
      * @note   时间戳转换为时分秒
      * @param timestamp
      * @param format
      * @return
      */
    def longToTime(timestamp:Long,format:String, duration:Long=0L ): String ={
        var datetime = ""
        try {
            val simpleDateFormat = new SimpleDateFormat(format)
            datetime = simpleDateFormat.format(new Date(timestamp + duration))
        } catch {
            case e:Exception =>println(">>>>>>时间戳解析异常Exception: " + e)
        }
        datetime
    }

    /**
      * @note   时间戳转换为指定的日期格式
      * @param timestamp
      * @param format 指定的日期格式
      * @return
      */
    def timestampConvertDate(timestamp:Long, format:String): String ={
        var datetime = timestamp.toString
        try {
            val simpleDateFormat = new SimpleDateFormat(format)
            datetime = simpleDateFormat.format(timestamp)
        } catch {
            case e:Exception =>println(">>>>>>时间戳解析异常Exception: " + e)
        }
        datetime
    }







}