Iterar sobre el rango de fechas (a la manera de Scala)

Solución:

Puedes utilizar plusDays:

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

Dadas las fechas de inicio y finalización:

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)

Por solo iterar de día, lo hago:

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

Esto ha demostrado ser lo suficientemente útil como para tener un pequeño objeto auxiliar para proporcionar un implícito y permitir una transformación de tipo:

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

Uso de muestra:

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

Solución con API java.time usando Scala

Importación e inicialización necesarias

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

val now = LocalDate.now
val daysTill = 5

Crear lista de LocalDate para la duración de la muestra

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

Itera sobre fechas específicas entre el inicio y el final usando toEpochDay o 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)

---

---

Utiliza Nuestro Buscador