Bir günün başlangıç ​​ve bitiş zamanı nasıl elde edilir?

bunun gibi bir kod doğru değil:

 private Date getStartOfDay(Date date) {
    Calendar calendar = Calendar.getInstance();
    int year = calendar.get(Calendar.YEAR);
    int month = calendar.get(Calendar.MONTH);
    int day = calendar.get(Calendar.DATE);
    calendar.set(year, month, day, 0, 0, 0);
    return calendar.getTime();
}

private Date getEndOfDay(Date date) {
    Calendar calendar = Calendar.getInstance();
    int year = calendar.get(Calendar.YEAR);
    int month = calendar.get(Calendar.MONTH);
    int day = calendar.get(Calendar.DATE);
    calendar.set(year, month, day, 23, 59, 59);
    return calendar.getTime();
}

Milisaniye için doğru değil.

tl; Dr.

LocalDate                       // Represents an entire day, without time-of-day and without time zone.
.now(                           // Capture the current date.
    ZoneId.of( "Asia/Tokyo" )   // Returns a `ZoneId` object.
)                               // Returns a `LocalDate` object.
.atStartOfDay(                  // Determines the first moment of the day as seen on that date in that time zone. Not all days start at 00:00!
    ZoneId.of( "Asia/Tokyo" ) 
)                               // Returns a `ZonedDateTime` object.

Gün başlangıcı

Bir saat diliminde görüldüğü şekliyle bugünün tam uzunluğunu alın.

Başlangıçın kapsayıcı olduğu, sonun ise özel olduğu Yarı Açık yaklaşımı kullanma . Bu yaklaşım, kodunuzdaki günün son saniyesini hesaba katmayan kusurları çözer.

ZoneId zoneId = ZoneId.of( "Africa/Tunis" ) ;
LocalDate today = LocalDate.now( zoneId  ) ;

ZonedDateTime zdtStart = today.atStartOfDay( zoneId ) ;
ZonedDateTime zdtStop = today.plusDays( 1 ).atStartOfDay( zoneId ) ;

zdtStart.toString () = 2020-01-30T00: 00 + 01: 00 [Afrika / Tunus]

zdtStop.toString () = 2020-01-31T00: 00 + 01: 00 [Afrika / Tunus]

Aynı anları UTC'de görün.

Instant start = zdtStart.toInstant() ;
Instant stop = zdtStop.toInstant() ;

start.toString () = 2020-01-29T23: 00: 00Z

stop.toString () = 2020-01-30T23: 00: 00Z

Bir tarihin tüm gününün saat dilimi yerine UTC'de görünmesini istiyorsanız, kullanın OffsetDateTime.

LocalDate today = LocalDate.now( ZoneOffset.UTC  ) ;

OffsetDateTime odtStart = today.atTime( OffsetTime.MIN ) ;
OffsetDateTime odtStop = today.plusDays( 1 ).atTime( OffsetTime.MIN ) ;

odtStart.toString () = 2020-01-30T00: 00 + 18: 00

odtStop.toString () = 2020-01-31T00: 00 + 18: 00

Bu OffsetDateTime nesneler zaten UTC'de olacaktır, ancak toInstanttanımları gereği her zaman UTC'de olan bu tür nesnelere ihtiyacınız varsa çağırabilirsiniz .

Instant start = odtStart.toInstant() ;
Instant stop = odtStop.toInstant() ;

start.toString () = 2020-01-29T06: 00: 00Z

stop.toString () = 2020-01-30T06: 00: 00Z

İpucu: Bu nesne çiftini temsil etmek üzere sınıfını kullanmak için ThreeTen-Extra kitaplığını projenize eklemek ilginizi çekebilir . Gibi karşılaştırma için Bu sınıf teklifler kullanışlı yöntemler , , ve daha fazlası.IntervalInstantabutsoverlapscontains

Interval interval = Interval.of( start , stop ) ;

interval.toString () = 2020-01-29T06: 00: 00Z / 2020-01-30T06: 00: 00Z

Yarı açık

Mprivat tarafından cevap doğrudur. Onun amacı, bir günün sonunu elde etmeye çalışmak değil, "ertesi gün başlamadan önce" ile karşılaştırmaktır. Onun fikri, bir zaman diliminin kapsayıcı bir başlangıca sahip olduğu , sonun ise özel olduğu "Yarı Açık" yaklaşım olarak bilinir .

• Java'nın geçerli tarih-saat çerçeveleri (java.util.Date/Calendar ve Joda-Time ), çağın milisaniyelerini kullanır . Ancak Java 8'de, yeni JSR 310 java.time. * Sınıfları nanosaniye çözünürlüğü kullanır. Günün son anının milisaniye sayımını zorlayarak yazdığınız herhangi bir kod, yeni sınıflara geçildiğinde yanlış olacaktır.
• Diğer kaynaklardan gelen verileri karşılaştırmak, başka çözünürlükler kullanırlarsa hatalı olur. Örneğin, Unix kitaplıkları tipik olarak tam saniyeleri kullanır ve Postgres gibi veritabanları tarih-saati mikrosaniye olarak çözümler.
• Bazı Gün Işığından Yararlanma Saati değişiklikleri gece yarısında meydana gelir ve bu durum işleri daha da karıştırabilir.

Joda-Time bu çok amaç için 2.3 teklifler bir yöntem, günün ilk anı elde etmek: withTimeAtStartOfDay(). Benzer şekilde java.time LocalDate::atStartOfDay,.

Daha fazla tartışma ve örnek görmek için StackOverflow'da "joda yarı açık" araması yapın .

Bill Schneider tarafından yazılan bu gönderiye bakın, Zaman aralıkları ve diğer aralıklar yarı açık olmalıdır .

Eski tarih-saat sınıflarından kaçının

Java.util.Date ve .Calendar sınıfları herkesin bildiği gibi zahmetlidir. Onlardan kaçının.

Java.time sınıflarını kullanın . Java.time çerçevesi son derece başarılı resmi halefi Joda-Time kütüphanesine.

java.time

Java.time çerçevesi, Java 8 ve sonraki sürümlerde yerleşiktir. Java 6 & 7 dön portlu ThreeTen-backport ayrıca, Android adapte projesi ThreeTenABP projesi.

An Instant, nanosaniye çözünürlükte UTC'de zaman çizelgesinde bir andır .

Instant instant = Instant.now();

Bazı yerler için duvar saatini öğrenmek için bir saat dilimi uygulayın .

ZoneId zoneId = ZoneId.of( "America/Montreal" );
ZonedDateTime zdt = ZonedDateTime.ofInstant( instant , zoneId );

Günün ilk anını öğrenmek için LocalDatedersi ve atStartOfDayyöntemini gözden geçirin.

ZonedDateTime zdtStart = zdt.toLocalDate().atStartOfDay( zoneId );

Yarı Açık yaklaşımını kullanarak, ertesi günün ilk anını alın.

ZonedDateTime zdtTomorrowStart = zdtStart.plusDays( 1 );

Şu anda java.time çerçevesi Interval, Joda-Time için aşağıda açıklandığı gibi bir sınıftan yoksundur . Bununla birlikte, ThreeTen-Extra projesi java.time'ı ek sınıflarla uzatır. Bu proje, java.time'a gelecekteki olası eklemeler için kanıtlayıcı zemindir. Sınıfları arasında Interval. Bir Construct Intervalbir çift geçirilerek Instantnesne. Biz çıkarabilir Instantbizim dan ZonedDateTimenesneler.

Interval today = Interval.of( zdtStart.toInstant() , zdtTomorrowStart.toInstant() );

Hakkında java.time

Java.time çerçevesi daha sonra Java 8 ve yerleşiktir. Bu sınıflar zahmetli eski yerini mirası gibi tarih-saat sınıfları java.util.Date, Calendar& SimpleDateFormat.

Daha fazla bilgi edinmek için Oracle Eğitimi'ne bakın . Ve birçok örnek ve açıklama için Stack Overflow'da arama yapın. Spesifikasyon JSR 310'dur .

Şu anda bakım modunda olan Joda-Time projesi, java.time sınıflarına geçişi tavsiye ediyor .

Sen değiştirebilir java.time sizin veritabanı ile doğrudan nesneleri. JDBC 4.2 veya üstü ile uyumlu bir JDBC sürücüsü kullanın . Dizelere gerek yok, derslere gerek yok . Hibernate 5 ve JPA 2.2 java.time'ı destekler .java.sql.*

Java.time derslerini nereden edinebilirim?

• Java SE 8 , Java SE 9 , Java SE 10 , Java SE 11 ve üstü - Paket uygulama ile standart Java API'sinin parçası.
  • Java 9 , bazı küçük özellikler ve düzeltmeler getirdi.
• Java SE 6 ve Java SE 7
  • Java.time işlevlerinin çoğu, ThreeTen-Backport'ta Java 6 ve 7'ye geri taşınır .
• Android
  • Android'in ( 26+ ) sonraki sürümleri, java.time sınıflarının uygulamalarını bir araya getirir .
  • Eski Android (<26) için, API ayıklama olarak bilinen bir süreç, orijinal olarak Android'de yerleşik olmayan java.time işlevinin bir alt kümesini getiriyor .
    • Desugaring ihtiyacınız olanı sunmuyorsa, ThreeTenABP projesi ThreeTen-Backport'u (yukarıda bahsedilen) Android'e uyarlar . ThreeTenABP nasıl kullanılır… konusuna bakın .

Joda-Time

GÜNCELLEME: Joda-Time projesi şu anda bakım modunda ve java.time sınıflarına geçişi tavsiye ediyor . Tarih için bu bölümü sağlam bırakıyorum.

Joda-Time çeşitli şekillerde bir zaman aralığını temsil etmek üç sınıf vardır: Interval, Period, ve Duration. Bir Intervalbir spesifik başlayan ve Evrenin çizelgesinde biten sahiptir. Bu, "bir günü" temsil etme ihtiyacımıza uyuyor.

withTimeAtStartOfDayGünün saatini sıfırlamaktan ziyade yöntemi çağırıyoruz . Yaz Saati Uygulaması ve diğer anormallikler nedeniyle günün ilk anı olmayabilir 00:00:00.

Joda-Time 2.3 kullanan örnek kod.

DateTimeZone timeZone = DateTimeZone.forID( "America/Montreal" );
DateTime now = DateTime.now( timeZone );
DateTime todayStart = now.withTimeAtStartOfDay();
DateTime tomorrowStart = now.plusDays( 1 ).withTimeAtStartOfDay();
Interval today = new Interval( todayStart, tomorrowStart );

Gerekirse, java.util.Date'e dönüştürebilirsiniz.

java.util.Date date = todayStart.toDate();

Java 8

public static Date atStartOfDay(Date date) {
    LocalDateTime localDateTime = dateToLocalDateTime(date);
    LocalDateTime startOfDay = localDateTime.with(LocalTime.MIN);
    return localDateTimeToDate(startOfDay);
}

public static Date atEndOfDay(Date date) {
    LocalDateTime localDateTime = dateToLocalDateTime(date);
    LocalDateTime endOfDay = localDateTime.with(LocalTime.MAX);
    return localDateTimeToDate(endOfDay);
}

private static LocalDateTime dateToLocalDateTime(Date date) {
    return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
}

private static Date localDateTimeToDate(LocalDateTime localDateTime) {
    return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
}

Güncelleme : Bu 2 yöntemi burada Java Yardımcı Programı Sınıflarıma ekledim

• DateUtils.atStartOfDay
• DateUtils.atEndOfDay

Şu adresteki Maven Merkezi Deposundadır:

<dependency>
  <groupId>com.github.rkumsher</groupId>
  <artifactId>utils</artifactId>
  <version>1.3</version>
</dependency>

Java 7 ve Öncesi

Apache Commons ile

public static Date atEndOfDay(Date date) {
    return DateUtils.addMilliseconds(DateUtils.ceiling(date, Calendar.DATE), -1);
}

public static Date atStartOfDay(Date date) {
    return DateUtils.truncate(date, Calendar.DATE);
}

Apache Commons olmadan

public Date atEndOfDay(Date date) {
    Calendar calendar = Calendar.getInstance();
    calendar.setTime(date);
    calendar.set(Calendar.HOUR_OF_DAY, 23);
    calendar.set(Calendar.MINUTE, 59);
    calendar.set(Calendar.SECOND, 59);
    calendar.set(Calendar.MILLISECOND, 999);
    return calendar.getTime();
}

public Date atStartOfDay(Date date) {
    Calendar calendar = Calendar.getInstance();
    calendar.setTime(date);
    calendar.set(Calendar.HOUR_OF_DAY, 0);
    calendar.set(Calendar.MINUTE, 0);
    calendar.set(Calendar.SECOND, 0);
    calendar.set(Calendar.MILLISECOND, 0);
    return calendar.getTime();
}

getEndOfDay alanına şunları ekleyebilirsiniz:

calendar.set(Calendar.MILLISECOND, 999);

Matematiksel olarak konuşulsa da, "sonraki günün başlangıcından önce" demek dışında bir günün sonunu belirleyemezsiniz.

Yani demek yerine, if(date >= getStartOfDay(today) && date <= getEndOfDay(today))diyorsun olmalıdır: if(date >= getStartOfDay(today) && date < getStartOfDay(tomorrow)). Bu çok daha sağlam bir tanımdır (ve milisaniye hassasiyeti konusunda endişelenmenize gerek yoktur).

java.time

java.timeJava 8'de yerleşik çerçeveyi kullanma .

import java.time.LocalTime;
import java.time.LocalDateTime;

LocalDateTime now = LocalDateTime.now(); // 2015-11-19T19:42:19.224
// start of a day
now.with(LocalTime.MIN); // 2015-11-19T00:00
now.with(LocalTime.MIDNIGHT); // 2015-11-19T00:00
// end of a day
now.with(LocalTime.MAX); // 2015-11-19T23:59:59.999999999

Günün başlangıcını java8 java.time.ZonedDateTime ile gitmek yerine bulmanın bir başka yolu LocalDateTimeda ZonedDateTime girişini DAYS olarak kısaltmaktır:

zonedDateTimeInstance.truncatedTo( ChronoUnit.DAYS );

Java 8 için aşağıdaki tek satır ifadeler çalışıyor. Bu örnekte UTC saat dilimini kullanıyorum. Lütfen şu anda kullandığınız Zaman Dilimini değiştirmeyi düşünün.

System.out.println(new Date());

final LocalDateTime endOfDay       = LocalDateTime.of(LocalDate.now(), LocalTime.MAX);
final Date          endOfDayAsDate = Date.from(endOfDay.toInstant(ZoneOffset.UTC));

System.out.println(endOfDayAsDate);

final LocalDateTime startOfDay       = LocalDateTime.of(LocalDate.now(), LocalTime.MIN);
final Date          startOfDayAsDate = Date.from(startOfDay.toInstant(ZoneOffset.UTC));

System.out.println(startOfDayAsDate);

Çıktı ile zaman farkı yoksa. Deneyin:ZoneOffset.ofHours(0)

Java 8 veya ThreeTenABP

ZonedDateTime

ZonedDateTime curDate = ZonedDateTime.now();

public ZonedDateTime startOfDay() {
    return curDate
    .toLocalDate()
    .atStartOfDay()
    .atZone(curDate.getZone())
    .withEarlierOffsetAtOverlap();
}

public ZonedDateTime endOfDay() {

    ZonedDateTime startOfTomorrow =
        curDate
        .toLocalDate()
        .plusDays(1)
        .atStartOfDay()
        .atZone(curDate.getZone())
        .withEarlierOffsetAtOverlap();

    return startOfTomorrow.minusSeconds(1);
}

// based on https://stackoverflow.com/a/29145886/1658268

LocalDateTime

LocalDateTime curDate = LocalDateTime.now();

public LocalDateTime startOfDay() {
    return curDate.atStartOfDay();
}

public LocalDateTime endOfDay() {
    return startOfTomorrow.atTime(LocalTime.MAX);  //23:59:59.999999999;
}

// based on https://stackoverflow.com/a/36408726/1658268

Umarım bu birine yardımcı olur.

Bu kodu denedim ve iyi çalışıyor!

final ZonedDateTime now = ZonedDateTime.now(ZoneOffset.UTC);
final ZonedDateTime startofDay =
    now.toLocalDate().atStartOfDay(ZoneOffset.UTC);
final ZonedDateTime endOfDay =
    now.toLocalDate().atTime(LocalTime.MAX).atZone(ZoneOffset.UTC);

Herhangi bir çerçeveye bağlı olmayan başka bir çözüm şudur:

static public Date getStartOfADay(Date day) {
    final long oneDayInMillis = 24 * 60 * 60 * 1000;
    return new Date(day.getTime() / oneDayInMillis * oneDayInMillis);
}

static public Date getEndOfADay(Date day) {
    final long oneDayInMillis = 24 * 60 * 60 * 1000;
    return new Date((day.getTime() / oneDayInMillis + 1) * oneDayInMillis - 1);
}

UTC tabanlı zaman döndürdüğünü unutmayın

private Date getStartOfDay(Date date) {
    Calendar calendar = Calendar.getInstance();
    int year = calendar.get(Calendar.YEAR);
    int month = calendar.get(Calendar.MONTH);
    int day = calendar.get(Calendar.DATE);
    calendar.setTimeInMillis(0);
    calendar.set(year, month, day, 0, 0, 0);
    return calendar.getTime();
    }

private Date getEndOfDay(Date date) {
    Calendar calendar = Calendar.getInstance();
    int year = calendar.get(Calendar.YEAR);
    int month = calendar.get(Calendar.MONTH);
    int day = calendar.get(Calendar.DATE);
    calendar.setTimeInMillis(0);
    calendar.set(year, month, day, 23, 59, 59);
    return calendar.getTime();
    }

calendar.setTimeInMillis (0); milisaniyeye kadar doğruluk sağlar

Biraz geç olduğunu biliyorum, ancak Java 8 söz konusu olduğunda, OffsetDateTime kullanıyorsanız (TimeZone, Nanosaniye vb. Gibi birçok avantaj sunar), aşağıdaki kodu kullanabilirsiniz:

OffsetDateTime reallyEndOfDay = someDay.withHour(23).withMinute(59).withSecond(59).withNano(999999999);
// output: 2019-01-10T23:59:59.999999999Z

Tüm çözümlerle ilgili birkaç sıkıntı yaşadım çünkü Anlık değişken türüne ihtiyacım vardı ve Zaman Dilimi her şeyi değiştirmeye her zaman müdahale etti, sonra çözümleri birleştirerek bunun iyi bir seçenek olduğunu gördüm.

        LocalDate today = LocalDate.now();
        Instant startDate = Instant.parse(today.toString()+"T00:00:00Z");
        Instant endDate = Instant.parse(today.toString()+"T23:59:59Z");

ve sonuç olarak sahibiz

        startDate = 2020-01-30T00:00:00Z
        endDate = 2020-01-30T23:59:59Z

Umarım sana yardımcı olur

Sanırım en kolayı şöyle bir şey olurdu:

// Joda Time

DateTime dateTime=new DateTime(); 

StartOfDayMillis = dateTime.withMillis(System.currentTimeMillis()).withTimeAtStartOfDay().getMillis();
EndOfDayMillis = dateTime.withMillis(StartOfDayMillis).plusDays(1).minusSeconds(1).getMillis();

Bu milisaniyeler daha sonra Joda Time ile ihtiyacınıza göre Takvim, Anlık veya Yerel Tarihe dönüştürülebilir.

public static Date beginOfDay(Date date) {
    Calendar cal = Calendar.getInstance();
    cal.setTime(date);
    cal.set(Calendar.HOUR_OF_DAY, 0);
    cal.set(Calendar.MINUTE, 0);
    cal.set(Calendar.SECOND, 0);
    cal.set(Calendar.MILLISECOND, 0);

    return cal.getTime();
}

public static Date endOfDay(Date date) {
    Calendar cal = Calendar.getInstance();
    cal.setTime(date);
    cal.set(Calendar.HOUR_OF_DAY, 23);
    cal.set(Calendar.MINUTE, 59);
    cal.set(Calendar.SECOND, 59);
    cal.set(Calendar.MILLISECOND, 999);

    return cal.getTime();
}