Lặp lại theo phạm vi ngày (theo cách thức)

Question

Cho ngày bắt đầu và ngày kết thúc, tôi muốn lặp lại theo ngày bằng cách sử dụng chức năng foreach, map hoặc tương tự. Một cái gì đó như

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

Tôi đang sử dụng https://github.com/nscala-time/nscala-time, nhưng tôi có được trả lại một đối tượng Joda Interval nếu tôi sử dụng cú pháp trên, mà tôi nghi ngờ cũng không phải là một phạm vi ngày, nhưng một loại phạm vi mili giây.

EDIT: Câu hỏi đã lỗi thời. Như được thông báo trên trang chủ joda, nếu bạn đang sử dụng java 8, bạn nên bắt đầu hoặc di chuyển đến java.time.

Answer 1

Bạn có thể sử dụng plusDays:

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

Với sự khởi đầu và ngày kết thúc:

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

bạn có thể sử dụng một cái gì đó như thế:

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

Đối với chỉ lặp lại theo ngày, tôi làm:

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

này được chứng minh là có đủ rằng tôi có một đối tượng helper nhỏ để cung cấp một tiềm ẩn và cho phép một loại chuyển đổi hữu ích: sử dụng

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

mẫu:

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 với API java.time sử dụng Scala

nhập khẩu cần thiết và khởi

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

val now = LocalDate.now 

Tạo Danh sách LocalDate cho thời gian mẫu

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

lặp qua ngày cụ thể giữa bắt đầu và kết thúc

//Extract the duration 
val duration = Period 
    .between(now, now.plusDays(5)) 
    .get(ChronoUnit.DAYS) 
//val duration = now.compareTo(now.plusDays(5)) 

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