有两个日期。 如何创建这些日期之间每月间隔的列表？

Question

Example (as 'dd.MM.yyyy HH:mm').

• java.util.Date begin = 21.01.2018 00:00

• java.util.Date end = 20.03.2018 00:00

I want to create java.util.List<MonthInterval> list like:

• 21.01.2018 00:00 — 01.02.2018 00:00 (or 31.01.2018 23:59:59)
• 01.02.2018 00:00 — 01.03.2018 00:00
• 01.03.2018 00:00 — 20.03.2018 00:00

My Class:

class MonthInterval {
    Date monthBegin, monthEnd;
}

I tried to do it myself. However, in the class java.util.Calendar I did not understand how to calculate the number of days in this or another month for this year. But I think I went the wrong way. Any ideas?

Answer 1

You should really use java.time API, there is some interesting stuff, using

class MonthInterval {

    static DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd.MM.yyyy HH:mm");

    LocalDateTime monthBegin, monthEnd;

    public MonthInterval(LocalDateTime monthBegin, LocalDateTime monthEnd) {
        this.monthBegin = monthBegin;
        this.monthEnd = monthEnd;
    }

    @Override
    public String toString() {
        return monthBegin.format(formatter) + " > " + monthEnd.format(formatter);
    }
}

You can do different ways, like

1. With do-while loop

    static List<MonthInterval> list(LocalDateTime begin, LocalDateTime end) { List<MonthInterval> list = new ArrayList<>(); LocalDateTime nextDayMonth; do { nextDayMonth = begin.plusMonths(1).withDayOfMonth(1); list.add(new MonthInterval(begin, nextDayMonth)); begin = nextDayMonth; } while (nextDayMonth.getMonthValue() != end.getMonthValue()); list.add(new MonthInterval(begin, end)); return list; } 

2. With for-i loop

    static List<MonthInterval> list(LocalDateTime begin, LocalDateTime end) { List<MonthInterval> list = new ArrayList<>(); LocalDateTime nextDayMonth; for (int i = 0; i < ChronoUnit.MONTHS.between(begin, end) + 1; i++) { nextDayMonth = begin.plusMonths(1).withDayOfMonth(1); list.add(new MonthInterval(begin, nextDayMonth)); begin = nextDayMonth; } list.add(new MonthInterval(begin, end)); return list; } 

To use as

static DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd.MM.yyyy HH:mm");

public static void main(String[] args) {
    LocalDateTime begin = LocalDateTime.parse("21.01.2018 00:00", formatter);
    LocalDateTime end = LocalDateTime.parse("20.03.2018 00:00", formatter);
    list(begin, end).forEach(System.out::println);
}

// And get
21.01.2018 00:00 > 01.02.2018 00:00
01.02.2018 00:00 > 01.03.2018 00:00
01.03.2018 00:00 > 20.03.2018 00:00

Answer 2

tl;dr

Interval.of(
    LocalDateTime.parse(                                    // Represent a date and a time-of-day but lacking a time zone or offset-from-UTC. So *not* a moment.
        "21.01.2018 00:00" ,
        DateTimeFormatter.ofPattern( "dd.MM.uuuu HH:mm" )   // Specify formatting pattern to match input strings.
    )                                                       // Returns a `LocalDateTime` object.
    .atZone(                                                // Apply a time zone to determine a moment.
        ZoneId.of( "Pacific/Auckland" )                     // Always use proper time zone in `Continent/Region` format, never 2-4 letter codes such as `IST` or `EST` or `PST`.
    )                                                       // Returns a `ZonedDateTime` object.
    .toInstant() ,                                          // Convert from a `ZonedDateTime` object to a `Instant` to adjust into UTC.
    …                                                       // Do the same as the above (the starting point) but for the stopping point.
)                                                           // Returns a `org.threeten.extra.Interval` object.
.toString()                                                 // Generate text representing both moments of this interval in standard ISO 8601 format, delimited by a `/` SOLIDUS character.

Avoid legacy date-time classes

Never use java.util.Date . That awful class was supplanted years ago by the modern java.time classes.

ThreeTen-Extra

The other Answer by azro is headed in the right direction. But there is no need to invent your own interval class. Look to the existing tried-and-true classes found in the ThreeTen-Extra project. That project is led by the same man, Stephen Colebourne, who led the JSR 310 java.time project and the Joda-Time project.

In the ThreeTen-Extra library you will find two class to represent a span-of-time attached to the timeline.

• Interval — A pair of moments in UTC, Instant objects.
• LocalDateRange — A pair of date-only values, LocalDate objects.

Moments

If you meant moments, parse your input strings at LocalDateTime objects. This are not moments, only potential moments, as they lack a time zone or offset-from-UTC.

DateTimeFormatter f = DateTimeFormatter.ofPattern( "dd.MM.uuuu HH:mm" ) ;
LocalDateTime ldt = LocalDateTime.parse( "21.01.2018 00:00" , f ) ;

Give those LocalDateTime real meaning by assigning a time zone to determine actual moment.

ZoneId z = ZoneId.of( "Africa/Tunis" ) ;
ZonedDateTime zdt = ldt.atZone( z ) ;

Adjust into UTC by extracting Instant . An Instant represents a moment always in UTC.

Instant instant = zdt.toInstant() ;

Pass a pair of such Instant objects to get an Interval .

org.threeten.extra.Interval interval = Interval.of( start , stop ) ;

You can compare Interval objects with handy methods such as isBefore , isAfter , overlaps , contains , encloses , and so on.

Dates

If you are focusing only on dates rather than moments, then use LocalDateRange . We must still process your inputs as seen above, as the date varies around the globe for any given moment. For example, a few minutes after midnight in Paris France is “tomorrow” while still “yesterday” in Montréal Québec.

For the dates, take the ZonedDateTime objects seen above and extract a LocalDate .

LocalDate ld = zdt.toLocalDate() ;  // Extract the date as seen at that moment through the wall-clock time used by the people of that region (that time zone).

Make a LocalDateRange with such dates

org.threeten.extra.LocalDateRange ldr = LocalDateRange.of( start , stop ) ;

Like Interval , the LocalDateRange class offers handy comparison methods such as overlaps , contains , etc.

Half-Open

21.01.2018 00:00 — 01.02.2018 00:00 (or 31.01.2018 23:59:59)

No, do not define a span-of-time by its last possible moment. That is awkward and problematic. One problem is an infinitely divisible fractional second.

Instead, use Half-Open method: the beginning is inclusive , while the ending is exclusive .

Search Stack Overflow for much more info.

---

About java.time

The java.time framework is built into Java 8 and later. These classes supplant the troublesome old legacy date-time classes such as java.util.Date , Calendar , & SimpleDateFormat .

The Joda-Time project, now in maintenance mode , advises migration to the java.time classes.

To learn more, see the Oracle Tutorial . And search Stack Overflow for many examples and explanations. Specification is JSR 310 .

You may exchange java.time objects directly with your database. Use a JDBC driver compliant with JDBC 4.2 or later. No need for strings, no need for java.sql.* classes.

Where to obtain the java.time classes?

• Java SE 8 , Java SE 9 , Java SE 10 , Java SE 11 , and later - Part of the standard Java API with a bundled implementation.
  • Java 9 adds some minor features and fixes.
• Java SE 6 and Java SE 7
  • Most of the java.time functionality is back-ported to Java 6 & 7 in ThreeTen-Backport .
• Android
  • Later versions of Android bundle implementations of the java.time classes.
  • For earlier Android (<26), the ThreeTenABP project adapts ThreeTen-Backport (mentioned above). See How to use ThreeTenABP… .

The ThreeTen-Extra project extends java.time with additional classes. This project is a proving ground for possible future additions to java.time. You may find some useful classes here such as Interval , YearWeek , YearQuarter , and more .