迭代日期范围（scala方式）

Given a start and an end date I would like to iterate on it by day using a foreach, map or similar function. Something like

鉴于开始日期和结束日期,我希望白天使用foreach,map或类似函数对其进行迭代。就像是

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

I am using https://github.com/nscala-time/nscala-time, but I get returned a joda Interval object if I use the syntax above, which I suspect is also not a range of dates, but a sort of range of milliseconds.

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

EDIT: The question is obsolete. As advised on the joda homepage, if you are using java 8 you should start with or migrate to java.time.

编辑:这个问题已经过时了。正如joda主页上所建议的那样,如果你使用的是java 8,你应该从java.time开始或者迁移到java.time。

7 个解决方案

#1

You may use plusDays:

你可以使用plusDays:

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

Given start and end dates:

给定开始和结束日期:

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)

#2

For just iterating by day, I do:

对于白天迭代,我做:

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

This has proven to be useful enough that I have a small helper object to provide an implicit and allow for a type transformation:

这已被证明是有用的,我有一个小的辅助对象来提供隐式和允许类型转换:

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)
  }
}

Sample usage:

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

#3

This answer fixes the issue of mrsrinivas answer, that .get(ChronoUnits.DAYS) returns only the days part of the duration, and not the total number of days.

这个答案解决了mrsrinivas答案的问题,即.get(ChronoUnits.DAYS)仅返回持续时间的天数部分,而不是总天数。

Necessary import and initialization

必要的导入和初始化

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

Note how above answer would lead to wrong result (total number of days is 117)

注意上面的答案会导致错误的结果(总天数是117)

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

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

Iterate over specific dates between start and end

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

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)

#4

Solution with java.time API using Scala

使用Scala的java.time API解决方案

Necessary import and initialization

必要的导入和初始化

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

val now = LocalDate.now
val daysTill = 5

Create List of LocalDate for sample duration

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

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

Iterate over specific dates between start and end using toEpochDay or getLong(ChronoField.EPOCH_DAY)

使用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)

#5

you can use something like that:

你可以使用这样的东西:

 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)))
 }

#6

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
}

#7

In this case, the Scala way is the Java way:

在这种情况下,Scala方式是Java方式:

When running Scala on Java 9+, we can use java.time.LocalDate::datesUntil:

在Java 9+上运行Scala时,我们可以使用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)

And if the last date is to be included:

如果要包含最后日期:

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