遍历日期范围（scala 方式）

Question

给定开始日期和结束日期，我想使用 foreach、map 或类似函数按天对其进行迭代。像

(DateTime.now to DateTime.now + 5.day by 1.day).foreach(println)

我正在使用 https://github.com/nscala-time/nscala-time，但如果我使用上面的语法，我会返回一个 joda Interval 对象，我怀疑这也不是日期范围，而是某种毫秒范围。

编辑：问题已过时。根据 joda homepage, if you are using java 8 you should start with or migrate to java.time.

上的建议

Answer 1

您可以使用 plusDays:

val now = DateTime.now
(0 until 5).map(now.plusDays(_)).foreach(println)

给定的开始和结束日期：

import org.joda.time.Days

val start = DateTime.now.minusDays(5)
val end   = DateTime.now.plusDays(5)    

val daysCount = Days.daysBetween(start, end).getDays()
(0 until daysCount).map(start.plusDays(_)).foreach(println)

Answer 2

你可以使用类似的东西：

 object Test extends App {
   private val startDate: DateTime = DateTime.now()
   private val endDate: DateTime = DateTime.now().plusDays(5)
   private val interval: Interval = new Interval(startDate, endDate)
   Stream.from(0,1)
         .takeWhile(index => interval.contains(startDate.plusDays(index)))
         .foreach(index => println(startDate.plusDays(index)))
 }

Answer 3

为了按天迭代，我这样做：

Iterator.iterate(start) { _ + 1.day }.takeWhile(_.isBefore(end))

这已被证明非常有用，我有一个小的辅助对象来提供隐式并允许类型转换：

object IntervalIterators {
  implicit class ImplicitIterator(val interval: Interval) extends AnyVal {
    def iterateBy(step: Period): Iterator[DateTime] = Iterator.iterate(interval.start) { _ + step }
        .takeWhile(_.isBefore(interval.end))

    def iterateBy[A](step: Period, transform: DateTime => A): Iterator[A] = iterateBy(step).map(transform)

    def iterateByDay: Iterator[LocalDate] = iterateBy(1.day, { _.toLocalDate })

    def iterateByHour: Iterator[DateTime] = iterateBy(1.hour)
  }
}

示例用法：

import IntervalIterators._

(DateTime.now to 5.day.from(DateTime.now)).iterateByDay // Iterator[LocalDate]

(30.minutes.ago to 1.hour.from(DateTime.now)).iterateBy(1.second)  // Iterator[DateTime], broken down by second

Answer 4

Solution with java.time API using Scala

必要的导入和初始化

import java.time.temporal.ChronoUnit
import java.time.temporal.ChronoField.EPOCH_DAY
import java.time.{LocalDate, Period}

val now = LocalDate.now
val daysTill = 5

创建样本持续时间 LocalDate 的列表

(0 to daysTill)
  .map(days => now.plusDays(days))
  .foreach(println)

使用 toEpochDay 或 getLong(ChronoField.EPOCH_DAY)

迭代开始和结束之间的特定日期

//Extract the duration
val endDay = now.plusDays(daysTill)
val startDay = now

val duration = endDay.getLong(EPOCH_DAY) - startDay.getLong(EPOCH_DAY)

/* This code does not give desired results as trudolf pointed
val duration = Period
  .between(now, now.plusDays(daysTill))
  .get(ChronoUnit.DAYS)
*/

//Create list for the duration
(0 to duration)
  .map(days => now.plusDays(days))
  .foreach(println)

Answer 5

import java.util.{Calendar, Date}
import scala.annotation.tailrec

/** Gets date list between two dates
  *
  * @param startDate  Start date
  * @param endDate    End date
  * @return           List of dates from startDate to endDate
  */
def getDateRange(startDate: Date, endDate: Date): List[Date] = {
  @tailrec
  def addDate(acc: List[Date], startDate: Date, endDate: Date): List[Date] = {
    if (startDate.after(endDate)) acc
    else addDate(endDate :: acc, startDate, addDays(endDate, -1))
  }

  addDate(List(), startDate, endDate)
}

/** Adds a date offset to the given date
  *
  * @param date       ==> Date
  * @param amount     ==> Offset (can be negative)
  * @return           ==> New date
  */
def addDays(date: Date, amount: Int): Date = {
  val cal = Calendar.getInstance()
  cal.setTime(date)
  cal.add(Calendar.DATE, amount)
  cal.getTime
}

Answer 6

此答案修复了 mrsrinivas 答案的问题，即 .get(ChronoUnits.DAYS) returns 只是持续时间的天数部分，而不是总天数。

必要的导入和初始化

import java.time.temporal.ChronoUnit
import java.time.{LocalDate, Period}

请注意以上答案将如何导致错误结果（总天数为 117）

scala> Period.between(start, end)
res6: java.time.Period = P3M26D

scala> Period.between(start, end).get(ChronoUnit.DAYS)
res7: Long = 26

迭代开始和结束之间的特定日期

val start = LocalDate.of(2018, 1, 5)
val end   = LocalDate.of(2018, 5, 1)

// Create List of `LocalDate` for the period between start and end date

val dates: IndexedSeq[LocalDate] = (0L to (end.toEpochDay - start.toEpochDay))
  .map(days => start.plusDays(days))

dates.foreach(println)

Answer 7

在这种情况下，Scala way 是 Java way:

当运行Scala在Java 9+时，我们可以使用java.time.LocalDate::datesUntil:

import java.time.LocalDate
import collection.JavaConverters._

// val start = LocalDate.of(2019, 1, 29)
// val end   = LocalDate.of(2018, 2,  2)
start.datesUntil(end).iterator.asScala
// Iterator[java.time.LocalDate] = <iterator> (2019-01-29, 2019-01-30, 2019-01-31, 2019-02-01)

如果要包括最后一个日期：

start.datesUntil(end.plusDays(1)).iterator.asScala
// 2019-01-29, 2019-01-30, 2019-01-31, 2019-02-01, 2019-02-02

遍历日期范围（scala 方式）

Iterate over dates range (the scala way)

iteration

datetime

scala

nscala-time