Java 8'de iki tarih arasındaki günleri hesaplama

Ben SO hakkında nasıl soruları bir sürü olduğunu biliyorum, ama ben istiyorum ve yeni Java 8 Tarih api kullanarak örnek. JodaTime kütüphanesini de biliyorum, ama harici kütüphaneler olmadan bir çalışma yolu istiyorum.

Fonksiyonun bu kısıtlamalardan şikayet etmesi gerekir:

1. Tarihten itibaren hataları önleme
2. Girdi iki Date nesneleridir (zaman olmadan, localdatetime biliyorum, ama tarih örnekleri ile yapmak gerekir)

Mantıksal takvim günleri istiyorsanız , aşağıdaki DAYS.between()yöntemlerden birini kullanın java.time.temporal.ChronoUnit:

LocalDate dateBefore;
LocalDate dateAfter;
long daysBetween = DAYS.between(dateBefore, dateAfter);

İsterseniz 24 literal saatlik günler (a süre ), kullanabilirsiniz Durationsınıf yerine:

LocalDate today = LocalDate.now()
LocalDate yesterday = today.minusDays(1);
// Duration oneDay = Duration.between(today, yesterday); // throws an exception
Duration.between(today.atStartOfDay(), yesterday.atStartOfDay()).toDays() // another option

Daha fazla bilgi için bu belgeye bakın .

VGR'nin yorumlarına dayanarak şunları kullanabilirsiniz:

ChronoUnit.DAYS.between(firstDate, secondDate)

Şunları kullanabilirsiniz until():

LocalDate independenceDay = LocalDate.of(2014, Month.JULY, 4);
LocalDate christmas = LocalDate.of(2014, Month.DECEMBER, 25);

System.out.println("Until christmas: " + independenceDay.until(christmas));
System.out.println("Until christmas (with crono): " + independenceDay.until(christmas, ChronoUnit.DAYS));

Şunlardan kullanabilirsiniz DAYS.between:java.time.temporal.ChronoUnit

Örneğin

import java.time.temporal.ChronoUnit;

public long getDaysCountBetweenDates(LocalDate dateBefore, LocalDate dateAfter) {
    return DAYS.between(dateBefore, dateAfter);
}

Eğer startDate ve endDate örneği olan java.util.Date

ChronoUnit enum'daki between () yöntemini kullanabiliriz :

public long between(Temporal temporal1Inclusive, Temporal temporal2Exclusive) {
    //..
}

ChronoUnit.DAYS, 24 saati tamamlayan günleri sayar .

import java.time.temporal.ChronoUnit;

ChronoUnit.DAYS.between(startDate.toInstant(), endDate.toInstant());

//OR 

ChronoUnit.DAYS.between(Instant.ofEpochMilli(startDate.getTime()), Instant.ofEpochMilli(endDate.getTime()));

Je.time.temporal.ChronoUnit enum içindeki DAYS işlevini kullanın . Örnek Kod aşağıdadır:

Çıktı: * Başlangıç ​​tarihi: 2015-03-01 ve bitiş tarihi arasındaki gün sayısı: 2016-03-03 ==> 368'dir. ** Başlangıç ​​tarihi: 2016-03-03 ve bitiş tarihi arasındaki gün sayısı: 2015-03-01 ==> -368 *

package com.bitiknow.date;

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;

/**
 * 
 * @author pradeep
 *
 */
public class LocalDateTimeTry {
    public static void main(String[] args) {

        // Date in String format.
        String dateString = "2015-03-01";

        // Converting date to Java8 Local date
        LocalDate startDate = LocalDate.parse(dateString);
        LocalDate endtDate = LocalDate.now();
        // Range = End date - Start date
        Long range = ChronoUnit.DAYS.between(startDate, endtDate);
        System.out.println("Number of days between the start date : " + dateString + " and end date : " + endtDate
                + " is  ==> " + range);

        range = ChronoUnit.DAYS.between(endtDate, startDate);
        System.out.println("Number of days between the start date : " + endtDate + " and end date : " + dateString
                + " is  ==> " + range);

    }

}

Herkes ChronoUnit.DAYS.between'i kullanıyor ama bu sadece kendinizi çağırabileceğiniz başka bir yönteme delege ediyor. Böylece yapabilirsin firstDate.until(secondDate, ChronoUnit.DAYS).

Her ikisi için de dokümanlar aslında her iki yaklaşımdan da bahsediyor ve hangisinin daha okunabilir olduğunu gösteriyor.

Hadi bakalım:

public class DemoDate {
    public static void main(String[] args) {
        LocalDate today = LocalDate.now();
        System.out.println("Current date: " + today);

        //add 1 month to the current date
        LocalDate date2 = today.plus(1, ChronoUnit.MONTHS);
        System.out.println("Next month: " + date2);

        // Put latest date 1st and old date 2nd in 'between' method to get -ve date difference
        long daysNegative = ChronoUnit.DAYS.between(date2, today);
        System.out.println("Days : "+daysNegative);

        // Put old date 1st and new date 2nd in 'between' method to get +ve date difference
        long datePositive = ChronoUnit.DAYS.between(today, date2);
        System.out.println("Days : "+datePositive);
    }
}

Mevcut günden Noel öncesi gün sayısını alın, bunu deneyin

System.out.println(ChronoUnit.DAYS.between(LocalDate.now(),LocalDate.of(Year.now().getValue(), Month.DECEMBER, 25)));

Amaç sadece günler arasındaki farkı elde etmekse ve yukarıdaki cevaplar delege yöntemlerinden bahsettiğinde, bir zamanlar da sadece

public long daysInBetween(java.time.LocalDate startDate, java.time.LocalDate endDate) {
  // Check for null values here

  return endDate.toEpochDay() - startDate.toEpochDay();
}

iki tarih arasındaki günleri almak tarih java.util.Date örneğidir

public static long daysBetweenTwoDates(Date dateFrom, Date dateTo) {
            return DAYS.between(Instant.ofEpochMilli(dateFrom.getTime()), Instant.ofEpochMilli(dateTo.getTime()));
        }

Bu sorunun Java 8 için olduğunu biliyorum, ancak Java 9 ile şunları kullanabilirsiniz:

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

İhtiyaçlarınızı en iyi karşılayan sınıfı veya yöntemi kullanın:

• Süre sınıfı,
• Dönem sınıfı,
• veya ChronoUnit.between yöntemini kullanın.

A Süre, zamana dayalı değerleri (saniye, nanosaniye) kullanarak bir süreyi ölçer.

Dönem, tarihe dayalı değerleri (yıl, ay, gün) kullanır.

ChronoUnit.between yöntemi, yalnızca gün veya saniye gibi tek bir zaman birimindeki süreyi ölçmek istediğinizde kullanışlıdır.

https://docs.oracle.com/javase/tutorial/datetime/iso/period.html