java1.8时间处理

object TimeUtils {

  var DEFAULT_FORMAT = DateTimeFormatter.ofPattern("yyyyMMddHHmmss")
  var HOUR_FORMAT = DateTimeFormatter.ofPattern("yyyyMMddHH")
  var DAY_FORMAT = DateTimeFormatter.ofPattern("yyyyMMdd")
  var MONTH_FORMAT = DateTimeFormatter.ofPattern("yyyyMM")
  var MONTH_LINK_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM")
  var YEAR_FORMAT = DateTimeFormatter.ofPattern("yyyy")
  var DAY_LINK_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd")
  /**
    * 以List[String]形式返回两个日期之间的所有天数日期
    * 如 begin：20170903  end ：20170906  返回[20170903,20170904,20170905,20170906]
    *
    * @param localStart
    * @param localEnd
    * @return
    */
  def findDatesBetween(localStart: LocalDateTime, localEnd: LocalDateTime): util.LinkedList[String] = {
    var localDateList = new util.LinkedList[String]()
    try {
      if (localStart.toLocalDate.equals(localEnd.toLocalDate)) {
        localDateList.add(DAY_FORMAT.format(localStart.toLocalDate))
        return localDateList
      }
      var length = ChronoUnit.DAYS.between(localStart.toLocalDate, localEnd.toLocalDate)
      while (length >= 0) {
        localDateList.add(DAY_FORMAT.format(localEnd.toLocalDate.minusDays(length)))
        length = length - 1
      }
    } catch {
      case ex => {
        println(ex.getStackTrace.mkString(","))
      }
    }
    return localDateList
  }


  def findHoursBetween(localStart: LocalDateTime, localEnd: LocalDateTime): util.LinkedList[String] = {
    var localDateList = new util.LinkedList[String]();
    try {
      if (localStart.toString.equals(localEnd.toString)) {
        localDateList.add(HOUR_FORMAT.format(localStart))
        return localDateList
      }
      var local = localEnd
      var length = ChronoUnit.HOURS.between(localStart, localEnd)
      while (length >= 0) {
        localDateList.add(HOUR_FORMAT.format(local))
        local = local.minusHours(1)
        length = length - 1
      }
    } catch {
      case ex => {
        println(ex.getStackTrace.mkString(","))
      }
    }
    return localDateList
  }

  /**
    * 计算粒度时间间天数
    *
    * @param time
    * @param granul
    * @return
    */
  def findDays(start: LocalDateTime, end: LocalDateTime): Long = {
    // jode  Days.daysBetween
    return ChronoUnit.DAYS.between(start.toLocalDate, end.toLocalDate) + 1
  }

  /**
    * 计算指定粒度的时间间隔的天数
    *
    * @param time
    * @param granul
    * @return
    */
  def calDays(time: String, granul: String): Long = {
    var end = findDayEnd(time, granul)
    var start = findDayStart(time, granul)
    if (end.isAfter(LocalDateTime.now)) {
      end = LocalDateTime.now
    }
    if (start.toLocalDate.equals(end.toLocalDate)) {
      return 1L
    }
    var res = findDays(start, end)
    if (res < 0) {
      return 1L
    }
    if (end.toLocalDate.equals(LocalDate.now())) {
      res = res - 1
    }
    res
  }

  def findDayStart(time: String, granul: String): LocalDateTime = {
    if (Constants.WEEK.equalsIgnoreCase(granul)) {
      return getWeekStart(time)
    } else if (Constants.MONTH.equalsIgnoreCase(granul)) {
      return getMonthStart(time)
    } else if (Constants.SEASON.equalsIgnoreCase(granul)) {
      return getSeasonStart(time)
    } else if (Constants.YEAR.equalsIgnoreCase(granul)) {
      return getYearStart(time)
    } else if( Constants.DAY.equals(granul)) {
      return LocalDateTime.parse(time.replaceAll("-|\\s", "").substring(0, 8) + "000000",
        new DateTimeFormatterBuilder().appendPattern("yyyyMMddHHmmss").toFormatter())
    } else {
      if (time.trim.length >= 11) {
        return LocalDateTime.parse(time.replaceAll("-", "").substring(0, 10) + "0000",
          new DateTimeFormatterBuilder().appendPattern("yyyyMMddHHmmss").toFormatter())
      }
      return LocalDateTime.parse(time.replaceAll("-", "").substring(0, 8) + "000000",
        new DateTimeFormatterBuilder().appendPattern("yyyyMMddHHmmss").toFormatter())
    }
  }

  def findDayEnd(time: String, granul: String): LocalDateTime = {
    if (Constants.WEEK.equalsIgnoreCase(granul)) {
      return getWeekEnd(time)
    } else if (Constants.MONTH.equalsIgnoreCase(granul)) {
      return getMonthEnd(time)
    } else if (Constants.SEASON.equalsIgnoreCase(granul)) {
      return getSeasonEnd(time)
    } else if (Constants.YEAR.equalsIgnoreCase(granul)) {
      return getYearEnd(time)
    } else if (Constants.HOUR.equals(granul)) {
      if (time.trim.length >= 11) {
        return LocalDateTime.parse(time.replaceAll("-|\\s", "").substring(0, 10) + "5959",
          new DateTimeFormatterBuilder().appendPattern("yyyyMMddHHmmss").toFormatter())
      }
      return LocalDateTime.parse(time.replaceAll("-", "").substring(0, 8) + "235959",
        new DateTimeFormatterBuilder().appendPattern("yyyyMMddHHmmss").toFormatter())
    } else {
      return LocalDateTime.parse(time.replaceAll("-", "").substring(0, 8) + "235959",
        new DateTimeFormatterBuilder().appendPattern("yyyyMMddHHmmss").toFormatter())
    }
  }

  /**
    *
    * @param time 2020 2020年第一天时间，即 2020-01-01
    * @return
    */
  def getYearStart(time: String): LocalDateTime = {
    val yearFirstDate = LocalDateTime.now
      .withYear(Integer.valueOf(time)).withMonth(1).withDayOfMonth(1)
    return getMin(yearFirstDate)
  }


  /**
    *
    * @param time 2020  2020年最后一天时间，即 2020-12-31
    * @return
    */
  def getYearEnd(time: String): LocalDateTime = {
    var yearEndDate = LocalDateTime.now
      .withYear(Integer.valueOf(time))
      .withMonth(12).`with`(TemporalAdjusters.lastDayOfMonth())
    var yearLastDateTime = getMax(yearEndDate)
    return yearLastDateTime
  }

  /**
    *
    * @param time 2020-02 2020年第二季度最后一天时间，即 2020-06-30 23:59:59
    * @return
    */
  def getSeasonEnd(time: String): LocalDateTime = {
    var seasonLastDate = LocalDateTime.now
      .withYear(Integer.valueOf(time.substring(0, time.lastIndexOf("-"))))
      .withMonth((Integer.valueOf(time.substring(time.lastIndexOf("-") + 1, time.length))) * 3).`with`(TemporalAdjusters.lastDayOfMonth())
    var seasonLastDateTime = getMax(seasonLastDate)
    return seasonLastDateTime
  }

  /**
    *
    * @param time 2020-02 2020年第二季度第一天时间，即 2020-04-01
    * @return
    */
  def getSeasonStart(time: String): LocalDateTime = {
    val seasonFirstDate = LocalDateTime.now
      .withYear(Integer.valueOf(time.substring(0, time.lastIndexOf("-"))))
      .withMonth((Integer.valueOf(time.substring(time.lastIndexOf("-") + 1)) - 1) * 3 + 1).withDayOfMonth(1)
    return getMin(seasonFirstDate)

  }

  /**
    *
    * @param time 2020-02 2020年2月第一天时间，即 2020-02-01
    * @return
    */
  def getMonthStart(time: String): LocalDateTime = {
    val now = LocalDateTime.now
    var monthStartDate = now.withYear(Integer.valueOf(time.substring(0, time.lastIndexOf("-"))))
      .withMonth(Integer.valueOf(time.substring(time.lastIndexOf("-") + 1, time.length))).withDayOfMonth(1)
    return getMin(monthStartDate)
  }

  /**
    *
    * @param time 2020-02 2020年2月最后一天时间，即 2020-02-29
    * @return
    */
  def getMonthEnd(time: String): LocalDateTime = {
    val now = LocalDateTime.now
    var lastDateOfMonth = now.withYear(Integer.valueOf(time.substring(0, time.lastIndexOf("-"))))
      .withMonth(Integer.valueOf(time.substring(time.lastIndexOf("-") + 1, time.length))).`with`(TemporalAdjusters.lastDayOfMonth())
    var monthLastDateTime = getMax(lastDateOfMonth)
    return monthLastDateTime
  }

  /**
    *
    * @param time 2020-03 2020年第三周开始时间，
    * @return
    */
  def getWeekStart(time: String): LocalDateTime = {
    val weekFields = WeekFields.of(DayOfWeek.MONDAY, 1)    
var lastDateTime = LocalDate.parse(time,
new DateTimeFormatterBuilder().appendPattern("YYYY-w").parseDefaulting(weekFields.dayOfWeek(), 1).toFormatter())      .`with`(DayOfWeek.
MONDAY)    
if("01".equals(time.substring(5))){      
if(getWeekStartNotAdjusted(time).isAfter(getYearStart(time.substring(0,4)))){        
return  getYearStart(time.substring(0,4)).toLocalDate.`with`(DayOfWeek.MONDAY).atTime(0,0,0) //获取time所在周的最后一天
      }    }    

if(getWeekStartNotAdjusted(time.substring(0,4) +"-01").isAfter(getYearStart(time.substring(0,4)))) {      lastDateTime.minusWeeks(
1).atTime(0,0,0)    }
else{      lastDateTime.atTime(
0,0,0)    }  }  


def getWeekStartNotAdjusted(time: String): LocalDateTime = {    
return getMin(LocalDate.parse(time,
new DateTimeFormatterBuilder().appendPattern("YYYY-w").parseDefaulting(WeekFields.ISO.dayOfWeek(), 1).toFormatter()).atStartOfDay())  }  

/**
    *
    * @param time 2020-03 2020年第三周最后一天日期，如果当前时间在第三周内，end时间则为当前时间
* @return
*/
def getWeekEnd(time: String): LocalDateTime = {    
val weekFields = WeekFields.of(DayOfWeek.MONDAY, 1)    
var lastDateTime = LocalDate.parse(time,
new DateTimeFormatterBuilder().appendPattern("YYYY-w").parseDefaulting(weekFields.dayOfWeek(), 1).toFormatter())      .`with`(DayOfWeek.
SUNDAY)    
if("01".equals(time.substring(5))){      
if(getWeekStartNotAdjusted(time).isAfter(getYearStart(time.substring(0,4)))){        
return  getYearStart(time.substring(0,4)).toLocalDate.`with`(DayOfWeek.SUNDAY).atTime(23,59,59) //获取time所在周的最后一天

      }    }    

if(getWeekStartNotAdjusted(time.substring(0,4) +"-01").isAfter(getYearStart(time.substring(0,4)))) {      lastDateTime.minusWeeks(
1).atTime(23,59,59)    }
else{      lastDateTime.atTime(
23,59,59)    }  }  



def parse(time: String): LocalDateTime = {    
if (StringUtils.isBlank(time)) {      
throw new NullPointerException()    }    

var timeTrimed = time.replaceAll("-|\\s|:|T", "")    
var pattern = "yyyyMMddHHmmss"
if (timeTrimed.length == 10) {      pattern = 
"yyyyMMddHH"
    }    
return LocalDateTime.parse(timeTrimed,
      DateTimeFormatter.ofPattern(pattern))  }  


def getMin(dateToMin: LocalDateTime): LocalDateTime = {    
return dateToMin.withHour(0).withMinute(0).withSecond(0)  }  


def getMax(dateToMax: LocalDateTime): LocalDateTime = {    
return dateToMax.withHour(23).withMinute(59).withSecond(59)  }  


/**
    *  获取对比日期 map
    * @param start
* @param end
* @param cstart
* @param cend
* @param cycle
* @return
*/
def getDMap(start:String, end:String,cstart:String,cend:String, cycle:String): util.LinkedHashMap[String,String] ={    
var rm = new util.LinkedHashMap[String,String]()    
if (Constants.DAY.equalsIgnoreCase(cycle)) {      
var ds = getLocalDaysBetween(start,end).toArray()      
var cds = getLocalDaysBetween(cstart,cend).toArray()      
if(ds.length == cds.length){        
for(i <- 0 until ds.length){          rm.put(ds(i).asInstanceOf[
String],cds(i).asInstanceOf[String])        }      }    }


else if (Constants.WEEK.equalsIgnoreCase(cycle)) {      
var ds = getLocalWeeksBetween(start,end).toArray()      
var cds = getLocalWeeksBetween(cstart,cend).toArray()      
if(ds.length == cds.length){        
for(i <- 0 until ds.length){          rm.put(ds(i).asInstanceOf[
String],cds(i).asInstanceOf[String])        }      }    }  


else if (Constants.MONTH.equalsIgnoreCase(cycle)) {      
var ds = getLocalMonthsBetween(start,end).toArray()      
var cds = getLocalMonthsBetween(cstart,cend).toArray()      
if(ds.length == cds.length){        
for(i <- 0 until ds.length){          rm.put(ds(i).asInstanceOf[
String],cds(i).asInstanceOf[String])        }      }    } 


else if (Constants.SEASON.equalsIgnoreCase(cycle)) {      
var ds = getLocalSeasonBetween(start,end).toArray()      
var cds = getLocalSeasonBetween(cstart,cend).toArray()      
if(ds.length == cds.length){        
for(i <- 0 until ds.length){          rm.put(ds(i).asInstanceOf[
String],cds(i).asInstanceOf[String])        }      }    } 


else if (Constants.YEAR.equalsIgnoreCase(cycle)) {      
var ds = getLocalYearBetween(start,end).toArray()      
var cds = getLocalYearBetween(cstart,cend).toArray()      
if(ds.length == cds.length){        
for(i <- 0 until ds.length){          rm.put(ds(i).asInstanceOf[
String],cds(i).asInstanceOf[String])        }      }    }    



return rm  }  


def getLocalDaysBetween(s:String,e:String): util.LinkedHashSet[String] ={    
var start = LocalDate.parse(s);
var end = LocalDate.parse(e)    
var dateList = new util.LinkedHashSet[String]()    
if(start.equals(end)){      dateList.add(
DAY_LINK_FORMAT.format(start))      
return dateList    }    

var it = start;
while(!it.isAfter(end)){      dateList.add(
DAY_LINK_FORMAT.format(it))      it = it.plusDays(
1)    }    dateList  }  




/**
    * 周
* @param start 2020-11
    * @param end 2020-13
    * @return 2020-11 2020-12 2020-13
    */
def getLocalWeeksBetween(start:String,end:String): util.LinkedHashSet[String] ={    
var weekList = new util.LinkedHashSet[String]()   
var startWeekStartDay = getWeekStart(start)    
var endWeekEndDay = getWeekEnd(end)    
var weeks = ChronoUnit.WEEKS.between(startWeekStartDay,endWeekEndDay)    weekList.add(
evaluateWeek(DAY_LINK_FORMAT.format(startWeekStartDay.toLocalDate)))    
var tw = startWeekStartDay.plusWeeks(1)    
for( i <- 1 to  weeks.toInt){      
if(!tw.isAfter(endWeekEndDay)){ weekList.add(evaluateWeek(DAY_LINK_FORMAT.format(tw.toLocalDate)))        tw = tw.plusWeeks(
1)      }    }    weekList  }  





/**
    * 月
* @param start 2019-12
    * @param end 2020-02
    * @return 2019-12 2020-01 2020-02
    */
def getLocalMonthsBetween(start:String,end:String): util.LinkedHashSet[String] ={    
var monthSet = new util.LinkedHashSet[String]()    
var startMonthStartDay = getMonthStart(start)    
var endMonthEndDay = getMonthEnd(end)    
var months = ChronoUnit.MONTHS.between(startMonthStartDay,endMonthEndDay)    monthSet.add(

MONTH_LINK_FORMAT.format(startMonthStartDay))    
var tm = startMonthStartDay.plusMonths(1);
for( i <- 1 to  months.toInt){      
if(!tm.isAfter(endMonthEndDay)){        monthSet.add(
MONTH_LINK_FORMAT.format(tm))        tm = tm.plusMonths(
1)      }    }    monthSet  }  





/**
    * 季
* @param start 2020-01
    * @param end 2020-03
    * @return 2020-01 2020-02 2020-03
    */
def getLocalSeasonBetween(start:String,end:String): util.LinkedHashSet[String] ={    
var monthSet = new util.LinkedHashSet[String]()    
var startSeasonStartDay = getSeasonStart(start)    
var endSeasonEndDay = getSeasonEnd(end)    
var season = (ChronoUnit.MONTHS.between(startSeasonStartDay,endSeasonEndDay) + 1)/3
    monthSet.add(startSeasonStartDay.getYear +"-"+ getTimeSeason(startSeasonStartDay.toLocalDate))    
var tm = startSeasonStartDay.plusMonths(3);
for( i <- 1 to  season.toInt){      
if(!tm.isAfter(endSeasonEndDay)){        monthSet.add(tm.getYear +
"-"+ getTimeSeason(tm.toLocalDate))        tm = tm.plusMonths(
3)      }    }    monthSet  }  





def getLocalYearBetween(start:String,end:String): util.LinkedHashSet[String] ={    
var yearSet = new util.LinkedHashSet[String]()    
var startYearStartDay = getYearStart(start)    
var endYearEndDay = getYearEnd(end)    
var season = (ChronoUnit.YEARS.between(startYearStartDay,endYearEndDay) + 1)    yearSet.add(startYearStartDay.getYear +
"")    
var tm = startYearStartDay.plusYears(1);
for( i <- 1 to  season.toInt){      
if(!tm.isAfter(endYearEndDay)){        yearSet.add(tm.getYear +
"")        tm = tm.plusYears(
1)      }    }    yearSet  }  





def getTimeSeason (localDate: LocalDate): String ={    
if(localDate.getMonthValue < 4){      
return "01"
    }    
if(localDate.getMonthValue >= 4 && localDate.getMonthValue < 7){      
return "02"
    }    
if(localDate.getMonthValue >= 7 && localDate.getMonthValue < 10){      
return "03"
    }    
return "04"
  }  

def evaluateWeek(time: String): String = {    
var timeDay = LocalDate.parse(time)    
val weekFields = WeekFields.of(DayOfWeek.MONDAY, 1)    
var weekEndDay = timeDay.`with`(DayOfWeek.SUNDAY) //获取time所在周的最后一天
var weekStartDay = timeDay.`with`(DayOfWeek.MONDAY) //获取time所在周的第一天

return weekEndDay.get(weekFields.weekBasedYear()) + "-" +StringUtils.leftPad(weekEndDay.get(weekFields.weekOfWeekBasedYear()) + "", 2, "0")

}