How to iterate through range of Dates in Java?

Asked 26/12, 2010 at 18:22 Answered 24/2 at 8:5

185

In my script I need to perform a set of actions through range of dates, given a start and end date.
Please provide me guidance to achieve this using Java.

for ( currentDate = starDate; currentDate < endDate; currentDate++) {

}

I know the above code is simply impossible, but I do it in order to show you what I'd like to achieve.

Strappado answered 26/12, 2010 at 18:22 Comment(0)

246

Well, you could do something like this using Java 8's time-API, for this problem specifically java.time.LocalDate (or the equivalent Joda Time classes for Java 7 and older)

for (LocalDate date = startDate; date.isBefore(endDate); date = date.plusDays(1))
{
    ...
}

I would thoroughly recommend using java.time (or Joda Time) over the built-in Date/Calendar classes.

Ashaashamed answered 26/12, 2010 at 18:26 Comment(5)

To expand on the point about Joda Time: trying to correctly implement this yourself is harder than one might think because of corner cases around changes to and from summer time. – Grallatorial 28/5, 2013 at 8:1

+1 for Joda, I hope someday it will reach it's land in the standard API. – Zirconium 28/8, 2013 at 12:29

@gyabraham: JSR-310 is looking in a pretty good shape for Java 8. – Ashaashamed 29/8, 2013 at 5:42

Can confirm this exact same code will work using Java 8's java.time.LocalDate instead of Joda. – Unready 21/3, 2016 at 13:5

The Joda-Time project is now in maintenance mode, and recommends migration to the java.time classes. As mentioned in comments, this Answer’s code works as-is in java.time, just change your import statements. – Obit 27/11, 2017 at 16:56

162

JodaTime is nice, however, for the sake of completeness and/or if you prefer API-provided facilities, here are the standard API approaches.

When starting off with java.util.Date instances like below:

SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
Date startDate = formatter.parse("2010-12-20");
Date endDate = formatter.parse("2010-12-26");

Here's the legacy java.util.Calendar approach in case you aren't on Java8 yet:

Calendar start = Calendar.getInstance();
start.setTime(startDate);
Calendar end = Calendar.getInstance();
end.setTime(endDate);

for (Date date = start.getTime(); start.before(end); start.add(Calendar.DATE, 1), date = start.getTime()) {
    // Do your job here with `date`.
    System.out.println(date);
}

And here's Java8's java.time.LocalDate approach, basically exactly the JodaTime approach:

LocalDate start = startDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
LocalDate end = endDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();

for (LocalDate date = start; date.isBefore(end); date = date.plusDays(1)) {
    // Do your job here with `date`.
    System.out.println(date);
}

If you'd like to iterate inclusive the end date, then use !start.after(end) and !date.isAfter(end) respectively.

Enteritis answered 26/12, 2010 at 20:14 Comment(0)

Java 8 style, using the java.time classes:

// Monday, February 29 is a leap day in 2016 (otherwise, February only has 28 days)
LocalDate start = LocalDate.parse("2016-02-28"),
          end   = LocalDate.parse("2016-03-02");

// 4 days between (end is inclusive in this example)
Stream.iterate(start, date -> date.plusDays(1))
        .limit(ChronoUnit.DAYS.between(start, end) + 1)
        .forEach(System.out::println);

Output:

Alternative:

LocalDate next = start.minusDays(1);
while ((next = next.plusDays(1)).isBefore(end.plusDays(1))) {
    System.out.println(next);
}

Java 9 added the datesUntil() method:

start.datesUntil(end.plusDays(1)).forEach(System.out::println);

Tall answered 11/10, 2015 at 0:54 Comment(2)

can you put multiples values ? for example: only monday or thursday or both – Grasp 27/12, 2017 at 14:51

I don't understand the question? Sounds like perhaps you're looking for Stream.filter. – Tall 16/12, 2021 at 7:12

This is essentially the same answer BalusC gave, but a bit more readable with a while loop in place of a for loop:

Calendar start = Calendar.getInstance();
start.setTime(startDate);

Calendar end = Calendar.getInstance();
end.setTime(endDate);

while( !start.after(end)){
    Date targetDay = start.getTime();
    // Do Work Here

    start.add(Calendar.DATE, 1);
}

Anaphrodisiac answered 8/3, 2013 at 18:33 Comment(1)

This will not work if the logic involves "continue" statements, while the for loop version of BalusC works with continue statements. – Ophthalmoscopy 29/12, 2014 at 15:13

Apache Commons

    for (Date dateIter = fromDate; !dateIter.after(toDate); dateIter = DateUtils.addDays(dateIter, 1)) {
        // ...
    }

Beers answered 31/7, 2015 at 16:36 Comment(1)

+1, IMHO, this is the cleanest one when you're working with old code. Just throw in an extra static import for addDays(..) and it gets even shorter. – Polarimeter 22/7, 2019 at 13:59

It’s built in: LocalDate.datesUntil() since Java 9

It seems that the answers until now have only been considering Java 8 and earlier. The Java 9+ way is:

    LocalDate startDate = LocalDate.of(2021, Month.JUNE, 29);
    LocalDate endDate = LocalDate.of(2021, Month.JULY, 3);
    
    startDate.datesUntil(endDate).forEach(System.out::println);

Output from this example is:

While the start date is inclusive, the end date is exclusive, as in your question the way I read it. If someone wants the end date to be included, it’s easy, just add a day to it:

    startDate.datesUntil(endDate.plusDays(1)).forEach(System.out::println);

You can obviously iterate several years in this way, just as you can put a lengthier lambda where I just put the method reference System.out::println for demonstration.

Links

Oracle tutorial: Date Time explaining how to use java.time.
Documentation of LocalDate.datesUntil(LocalDate)—

Hoeve answered 11/7, 2021 at 6:17 Comment(0)

private static void iterateBetweenDates(Date startDate, Date endDate) {
    Calendar startCalender = Calendar.getInstance();
    startCalender.setTime(startDate);
    Calendar endCalendar = Calendar.getInstance();
    endCalendar.setTime(endDate);

    for(; startCalender.compareTo(endCalendar)<=0;
          startCalender.add(Calendar.DATE, 1)) {
        // write your main logic here
    }

}

Higbee answered 31/10, 2014 at 9:23 Comment(0)

We can migrate the logic to various methods foe Java 7, Java 8 and Java 9:

public static List<Date> getDatesRangeJava7(Date startDate, Date endDate) {
    List<Date> datesInRange = new ArrayList<>();
    Calendar startCalendar = new GregorianCalendar();
    startCalendar.setTime(startDate);
    Calendar endCalendar = new GregorianCalendar();
    endCalendar.setTime(endDate);
    while (startCalendar.before(endCalendar)) {
        Date result = startCalendar.getTime();
        datesInRange.add(result);
        startCalendar.add(Calendar.DATE, 1);
    }
    return datesInRange;
}

public static List<LocalDate> getDatesRangeJava8(LocalDate startDate, LocalDate endDate) {
    int numOfDays = (int) ChronoUnit.DAYS.between(startDate, endDate);
    return IntStream.range(0, numOfDays)
            .mapToObj(startDate::plusDays)
            .collect(Collectors.toList());
}

public static List<LocalDate> getDatesRangeJava9(LocalDate startDate, LocalDate endDate) {
    return startDate.datesUntil(endDate).collect(Collectors.toList());
}

Then we can invoke these methods as:

SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
Date startDate = formatter.parse("2010-12-20");
Date endDate = formatter.parse("2010-12-26");
List<Date> dateRangeList = getDatesRangeJava7(startDate, endDate);
System.out.println(dateRangeList);

LocalDate startLocalDate = startDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
LocalDate endLocalDate = endDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
List<LocalDate> dateRangeList8 = getDatesRangeJava8(startLocalDate, endLocalDate);
System.out.println(dateRangeList8);
List<LocalDate> dateRangeList9 = getDatesRangeJava8(startLocalDate, endLocalDate);
System.out.println(dateRangeList9);

The output would be:

[Mon Dec 20 00:00:00 IST 2010, Tue Dec 21 00:00:00 IST 2010, Wed Dec 22 00:00:00 IST 2010, Thu Dec 23 00:00:00 IST 2010, Fri Dec 24 00:00:00 IST 2010, Sat Dec 25 00:00:00 IST 2010]

[2010-12-20, 2010-12-21, 2010-12-22, 2010-12-23, 2010-12-24, 2010-12-25]

[2010-12-20, 2010-12-21, 2010-12-22, 2010-12-23, 2010-12-24, 2010-12-25]

Preconcert answered 21/8, 2018 at 5:28 Comment(2)

The terrible Date and Calendar classes were supplanted by the java.time classes years ago. Specifically, replaced by Instant and ZonedDateDate. – Obit 21/8, 2018 at 6:4

I like the Java 8 and 9 ways. For Java 6 and 7 I recommend using the ThreeTen Backport library and then the same way as in Java 8. You demonstrate nicely how this way is clearer and more programmer-friendly. – Hoeve 21/8, 2018 at 9:24

public static final void generateRange(final Date dateFrom, final Date dateTo)
{
    final Calendar current = Calendar.getInstance();
    current.setTime(dateFrom);

    while (!current.getTime().after(dateTo))
    {
        // TODO

        current.add(Calendar.DATE, 1);
    }
}

Irremediable answered 25/3, 2016 at 9:43 Comment(0)

Here is Java 8 code. I think this code will solve your problem.Happy Coding

    LocalDate start = LocalDate.now();
    LocalDate end = LocalDate.of(2016, 9, 1);//JAVA 9 release date
    Long duration = start.until(end, ChronoUnit.DAYS);
    System.out.println(duration);
     // Do Any stuff Here there after
    IntStream.iterate(0, i -> i + 1)
             .limit(duration)
             .forEach((i) -> {});
     //old way of iteration
    for (int i = 0; i < duration; i++)
     System.out.print("" + i);// Do Any stuff Here

Tananarive answered 28/12, 2015 at 12:4 Comment(1)

This is best and easy approach that you can follow up. – Tananarive 13/1, 2016 at 18:28

Why not use epoch and loop through easily.

long startDateEpoch = new java.text.SimpleDateFormat("dd/MM/yyyy").parse(startDate).getTime() / 1000;

    long endDateEpoch = new java.text.SimpleDateFormat("dd/MM/yyyy").parse(endDate).getTime() / 1000;


    long i;
    for(i=startDateEpoch ; i<=endDateEpoch; i+=86400){

        System.out.println(i);

    }

Laurence answered 1/6, 2017 at 7:54 Comment(0)

You can write a class like it(implementing iterator interface) and iterate over it .

public class DateIterator implements Iterator<Date>, Iterable<Date>
{

 private Calendar end = Calendar.getInstance();
 private Calendar current = Calendar.getInstance();

 public DateIterator(Date start, Date end)
 {
     this.end.setTime(end);
     this.end.add(Calendar.DATE, -1);
     this.current.setTime(start);
     this.current.add(Calendar.DATE, -1);
 }

 @Override
 public boolean hasNext()
 {
     return !current.after(end);
 }

 @Override
 public Date next()
 {
     current.add(Calendar.DATE, 1);
     return current.getTime();
 }

 @Override
 public void remove()
 {
     throw new UnsupportedOperationException(
        "Cannot remove");
 }

 @Override
 public Iterator<Date> iterator()
 {
     return this;
 }
}

and use it like :

Iterator<Date> dateIterator = new DateIterator(startDate, endDate);
while(dateIterator.hasNext()){
      Date selectedDate = dateIterator .next();

}

Saddle answered 18/2, 2018 at 11:51 Comment(0)

You can try this:

OffsetDateTime currentDateTime = OffsetDateTime.now();
for (OffsetDateTime date = currentDateTime; date.isAfter(currentDateTime.minusYears(YEARS)); date = date.minusWeeks(1))
{
    ...
}

Gaberones answered 27/9, 2019 at 6:59 Comment(0)

This will help you start 30 days back and loop through until today's date. you can easily change range of dates and direction.

private void iterateThroughDates() throws Exception {
    Calendar start = Calendar.getInstance();
    start.add(Calendar.DATE, -30);
    Calendar end = Calendar.getInstance();
    for (Calendar date = start; date.before(end); date.add(Calendar.DATE, 1))
        {
        System.out.println(date.getTime());
        }
}

Boardwalk answered 8/2, 2017 at 6:51 Comment(1)

In modern Java, the terribly flawed date-time classes such as Calendar have been supplanted by the modern java.time classes defined in JSR 310. – Obit 24/2 at 8:0

The following snippet (uses java.time.format of Java 8) maybe used to iterate over a date range :

    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    // Any chosen date format maybe taken  
    LocalDate startDate = LocalDate.parse(startDateString,formatter);
    LocalDate endDate = LocalDate.parse(endDateString,formatter);
    if(endDate.isBefore(startDate))
    {
        //error
    }
    LocalDate itr = null;
    for (itr = startDate; itr.isBefore(endDate)||itr.isEqual(itr); itr = itr.plusDays(1))
    {
        //Processing  goes here
    }

The plusMonths()/plusYears() maybe chosen for time unit increment. Increment by a single day is being done in above illustration.

Garbe answered 8/10, 2020 at 14:54 Comment(0)

`LocalDate#datesUntil` ➡️ stream

In modern Java, you can use a stream of LocalDate objects rather than a for loop. Call LocalDate#datesUntil.

LocalDate start = LocalDate.of( 2024 , Month.JANUARY , 23 ) ;
LocalDate end = LocalDate.of( 2024 , Month.FEBRUARY , 14 ) ;
start
    .datesUntil( end )  // Returns a `Stream` of `LocalDate` objects. 
    .forEach( 
        System.out :: println  // Replace with your choice of actions.
    );

Obit answered 24/2 at 8:5 Comment(0)

Hot tags

Godot Unity Godot Help Programming Godot 4.X GUI GDScript 3D 2D Physics CSharp Godot 3.X VR XR Projects C++

It’s built in: LocalDate.datesUntil() since Java 9

Links

LocalDate#datesUntil ➡️ stream

Recommended topics

Hot tags

`LocalDate#datesUntil` ➡️ stream