java1.8时间处理

object TimeUtil {
 
  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 YEAR_FORMAT = DateTimeFormatter.ofPattern("yyyy")
 
  /**
    * 以List[String]形式返回两个日期之间的所有日期
    * 如 begin：20190903  end ：20190906  返回[20190903,20190904,20190905,20190906]
    *
    * @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.HOUR.equals(granul)) {
      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())
    } else {
      return LocalDateTime.parse(time.replaceAll("-|\\s", "") + "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 yearMonth = LocalDateTime.now
      .withYear(Integer.valueOf(time))
      .withMonth(12)
    var yearLastDateTime = getMax(yearMonthr.`with`(TemporalAdjusters.lastDayOfMonth()))
    return yearLastDateTime
  }
 
  /**
    *
    * @param time 2020-02 2020年第二季度最后一天时间，即 2020-06-30 23:59:59
    * @return
    */
  def getSeasonEnd(time: String): LocalDateTime = {
    var r = LocalDateTime.now
      .withYear(Integer.valueOf(time.substring(0, time.lastIndexOf("-"))))
      .withMonth((Integer.valueOf(time.substring(time.lastIndexOf("-") + 1, time.length))) * 3)
    var seasonLastDateTime = getMax(r.r.`with`(TemporalAdjusters.lastDayOfMonth()))
    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 r = now.withYear(Integer.valueOf(time.substring(0, time.lastIndexOf("-"))))
      .withMonth(Integer.valueOf(time.substring(time.lastIndexOf("-") + 1, time.length)))
    return getMin(r.withDayOfMonth(1))
  }
 
  /**
    *
    * @param time 2020-02 2020年2月最后一天时间，即 2020-02-29
    * @return
    */
  def getMonthEnd(time: String): LocalDateTime = {
    val now = LocalDateTime.now
    var r = now.withYear(Integer.valueOf(time.substring(0, time.lastIndexOf("-"))))
      .withMonth(Integer.valueOf(time.substring(time.lastIndexOf("-") + 1, time.length)))
    var monthLastDateTime = getMax(rr.`with`(TemporalAdjusters.lastDayOfMonth()))
    return monthLastDateTime
  }
 
  /**
    *
    * @param time 2020-03 2020年第三周开始时间，
    * @return
    */
  def getWeekStart(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 = {    
var lastDateTime = getMax(LocalDate.parse(time,
new DateTimeFormatterBuilder().appendPattern("YYYY-w").parseDefaulting(WeekFields.ISO.dayOfWeek(), 1).toFormatter()).atStartOfDay()      .`with`(TemporalAdjusters.
next(DayOfWeek.SUNDAY)))    
return lastDateTime  }  
 
def parse(tt: String): LocalDateTime = {    
if (StringUtils.isBlank(tt)) {      
throw new NullPointerException()    }    
 
var t = tt.replaceAll("-|\\s", "")    
var pattern = "yyyyMMddHHmmss"
if (t.length == 10) {      pattern = 
"yyyyMMddHH"
    }    
return LocalDateTime.parse(t,
new DateTimeFormatterBuilder().appendPattern(pattern).toFormatter())  }  
 
def getMin(tt: LocalDateTime): LocalDateTime = {    
return tt.withHour(0).withMinute(0).withSecond(0)  }  
 
def getMax(tt: LocalDateTime): LocalDateTime = {    
return tt.withHour(23).withMinute(59).withSecond(59)  }