दिन का शुरुआती समय और समाप्ति समय कैसे प्राप्त करें?

Question

दिन का शुरुआती समय और समाप्ति समय कैसे प्राप्त करें?

इस तरह कोड सटीक नहीं है:

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

यह मिलीसेकंड के लिए सही नहीं है।

Comments

आपका क्या मतलब है "यह सटीक नहीं है"?

— Kirk Woll

कोड में क्या गड़बड़ है? आप क्या कर रहे हैं कि आप उम्मीद नहीं है? आप अपने समय को किस क्षेत्र में शुरू और समाप्त करना चाहते हैं?

— मार्क रीड 1

उपरोक्त कोड विधि में पारित तारीख का उपयोग भी नहीं करता है। ऐसा करना चाहिए: कैलेंडर बनने के बाद Calendar.setTime (दिनांक)।

— जेरी डेस्ट्रेम्प्स

यह प्रश्न मानता है कि तिथि-समय मानों में मिलीसेकंड का एक रिज़ॉल्यूशन होता है। Java.util.Date और Joda-Time के लिए सही है। लेकिन जावा 8 (नैनोसेकंड) में जावा.टाइम पैकेज के लिए गलत, कुछ डेटाबेस जैसे पोस्टग्रेज (माइक्रोसेकंड), यूनिक्स लाइब्रेरी (पूरे सेकंड), और शायद अन्य। हाफ-ओपन का उपयोग करके सुरक्षित दृष्टिकोण के लिए मेरा जवाब देखें ।

— बेसिल बोर्क

वास्तव में आपको अगले दिन की शुरुआत मिलनी चाहिए और उस दिन में आइटम को पुनरावृत्त करते समय (यह मानते हुए कि आप ऐसा करना चाहते हैं) आप <= के बजाय <का उपयोग करके ऊपरी सीमा को निर्दिष्ट करेंगे। वह अगले दिन को बाहर कर देगा लेकिन पिछले दिन के सभी को नीचे नैनोसेकंड में शामिल कर देगा।

— डैनियल एफ

Answer 1

tl; डॉ

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.

दिन की शुरुआत

आज की पूरी लंबाई प्राप्त करें जैसा कि एक समय क्षेत्र में देखा जाता है।

हाफ-ओपन दृष्टिकोण का उपयोग करना, जहां शुरुआत समावेशी है जबकि अंत अनन्य है । यह दृष्टिकोण आपके कोड की खामियों को हल करता है जो दिन के बहुत अंतिम समय तक खाते में विफल रहता है।

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 [अफ्रीका / ट्यूनिस]

zdtStop.toString () = 2020-01-31T00: 00 + 01: 00 [अफ्रीका / ट्यूनिस]

यूटीसी में उसी क्षण देखें।

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

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

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

यदि आप एक समय क्षेत्र के बजाय UTC में देखे गए दिनांक का पूरा दिन चाहते हैं, तो उपयोग करें 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

ये OffsetDateTime ऑब्जेक्ट पहले से ही UTC में होंगे, लेकिन आप कॉल कर सकते हैं toInstantयदि आपको ऐसी ऑब्जेक्ट्स की जरूरत है जो हमेशा UTC में हों।

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

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

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

सुझाव: आप इस जोड़ी वस्तुओं का प्रतिनिधित्व करने के लिए अपनी कक्षा का उपयोग करने के लिए अपनी परियोजना में थ्रीटेन-अतिरिक्त पुस्तकालय को जोड़ने में रुचि रख सकते हैं। यह वर्ग तुलना के लिए उपयोगी तरीके प्रदान करता है जैसे ,IntervalInstantabutsoverlaps , contains, और अधिक।

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

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

आधा खुला

Mprivat द्वारा जवाब सही है। उनका कहना है कि एक दिन के अंत को प्राप्त करने की कोशिश न करें, बल्कि "अगले दिन की शुरुआत से पहले" की तुलना करें। उनके विचार को "हाफ-ओपन" दृष्टिकोण के रूप में जाना जाता है जहां समय की अवधि में एक शुरुआत होती है जो कि समावेशी होती है अंत में अनन्य होती है ।

• जावा की वर्तमान तिथि-समय की रूपरेखा (java.util.Date/Calendar और Joda-Time ) से दोनों का उपयोग मिलीसेकेंड युग । लेकिन जावा 8 में, नया JSR 310 java.time। * कक्षाएं नैनोसेकंड रिज़ॉल्यूशन का उपयोग करती हैं। आपके द्वारा लिखे गए किसी भी कोड को दिन के अंतिम क्षणों की मिलीसेकंड गणना के आधार पर लिखा जाता है, यदि नई कक्षाओं में स्विच किया जाता है तो यह गलत होगा।
• यदि वे अन्य प्रस्तावों को नियोजित करते हैं तो अन्य स्रोतों से डेटा की तुलना करना दोषपूर्ण हो जाता है। उदाहरण के लिए, यूनिक्स पुस्तकालय आमतौर पर पूरे सेकंड और डेटाबेस जैसे काम करते हैं पोस्टग्रेज माइक्रोसेकंड के लिए दिनांक-समय निर्धारित करते हैं।
• कुछ डेलाइट सेविंग टाइम परिवर्तन आधी रात को होते हैं जो आगे चलकर चीजों को भ्रमित कर सकते हैं।

Joda-Time 2.3 इस उद्देश्य के लिए एक विधि प्रदान करता है, दिन का पहला क्षण प्राप्त करने के लिए:withTimeAtStartOfDay() :। इसी तरह java.time में,LocalDate::atStartOfDay।

"Joda आधा खुला" के लिए StackOverflow खोजेंअधिक चर्चा और उदाहरण देखने के लिए ।

इस पोस्ट को देखें, , बिल श्नाइडर द्वारा टाइम अंतराल और अन्य रेंज आधी खुली होनी चाहिए ।

विरासत की तारीखों की कक्षाओं से बचें

Java.util.Date और। कैलेन्डर वर्ग कुख्यात हैं। इनसे बचें।

Java.time कक्षाओं का उपयोग करें । Java.time ढांचा बेहद सफल की आधिकारिक उत्तराधिकारी है Joda समय पुस्तकालय।

java.time

Java.time फ्रेमवर्क जावा 8 और बाद में बनाया गया है। थ्रीटेन-बैकपोर्ट प्रॉजेक्ट में जावा 6 और 7 के लिए बैक-पोर्ट किया गया, जो थ्रीटेनबप में एंड्रॉइड के लिए अनुकूल है। प्रोजेक्ट ।

एक Instantमें समय रेखा पर एक पल है यूटीसी के एक संकल्प के साथ नैनोसेकंड ।

Instant instant = Instant.now();

कुछ इलाके के लिए दीवार-घड़ी का समय प्राप्त करने के लिए एक समय क्षेत्र लागू करें ।

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

दिन का पहला क्षण प्राप्त करने के लिए LocalDateकक्षा और उसकी atStartOfDayविधि से गुजरें।

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

हाफ-ओपन दृष्टिकोण का उपयोग करते हुए, अगले दिन का पहला क्षण प्राप्त करें।

ZonedDateTime zdtTomorrowStart = zdtStart.plusDays( 1 );

वर्तमान में java.time ढांचे में एक Intervalवर्ग का अभाव है जैसा कि नीचे दिए गए Joda-Time के लिए वर्णित है। हालाँकि, थ्रीटेन-एक्स्ट्रा प्रोजेक्ट अतिरिक्त कक्षाओं के साथ java.time का विस्तार करता है। यह परियोजना java.time के लिए भविष्य के संभावित परिवर्धन के लिए साबित होने वाला आधार है। इसकी कक्षाओं के बीच है Interval। वस्तुओं के Intervalएक जोड़े को पारित करके निर्माण Instant। हम Instantअपनी ZonedDateTimeवस्तुओं से अर्क निकाल सकते हैं।

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

---

जावा के बारे में

Java.time ढांचे जावा 8 और बाद में बनाया गया है। इन कक्षाओं परेशानी वर्ष प्रतिस्थापित विरासत जैसे तिथि-समय कक्षाएं java.util.Date, Calendar, और SimpleDateFormat।

अधिक जानने के लिए, Oracle ट्यूटोरियल देखें । और कई उदाहरणों और स्पष्टीकरणों के लिए ढेर अतिप्रवाह खोजें। विशिष्टता JSR 310 है ।

Joda समय परियोजना, अब में रखरखाव मोड , प्रवास करने की सलाह देता java.time कक्षाएं।

आप अपने डेटाबेस से सीधे java.time वस्तुओं का आदान-प्रदान कर सकते हैं । JDBC 4.2 या उसके बाद के JDBC ड्राइवर का अनुपालन करें । तार की कोई जरूरत नहीं, कक्षाओं की कोई जरूरत नहीं । हाइबरनेट 5 और जेपीए 2.2 जावा का समर्थन करते हैं ।java.sql.*

Java.time कक्षाएं कहाँ से प्राप्त करें?

• जावा एसई 8 , जावा एसई 9 , जावा एसई 10 , जावा एसई 11 , और बाद में - बंडल कार्यान्वयन के साथ मानक जावा एपीआई का हिस्सा।
  • जावा 9 कुछ छोटी विशेषताओं और सुधारों को लाया।
• जावा एसई 6 और जावा एसई 7
  • जावा- टाइम की अधिकांश कार्यक्षमता थ्री-बैक-बैकपोर्ट में जावा 6 और 7 में बैक-पोर्ट की गई है ।
• एंड्रॉयड
  • Android के बाद के संस्करण (26+) java.time कक्षाओं के बंडल कार्यान्वयन ।
  • पहले एंड्रॉइड (<26) के लिए, एपीआई डिसुगरिंग के रूप में जानी जाने वाली प्रक्रिया जावा का एक सबसेट लाती है । टाइम कार्यक्षमता मूल रूप से एंड्रॉइड में नहीं बनाई गई है।
    • यदि डिगिंगिंग की आपको आवश्यकता नहीं है, तो थ्रीटेबैप प्रोजेक्ट थ्रीटेन-बैकपोर्ट (ऊपर उल्लेखित) को एंड्रॉइड में एडाप्ट करता है। देखें कि थ्रीटेनबप का उपयोग कैसे करें… ।

---

Joda समय

अद्यतन: जोडा-टाइम परियोजना अब रखरखाव-मोड में है, और माइग्रेशन को सलाह देती है java.time कक्षाओं में । मैं इस खंड को इतिहास के लिए बरकरार रख रहा हूं।

Joda समय विभिन्न तरीकों से समय की अवधि का प्रतिनिधित्व करने के तीन वर्गों है: Interval, Period, औरDuration । एक Intervalएक विशिष्ट शुरुआत और ब्रह्मांड के समय को समाप्त होने वाले हैं। यह "एक दिन" का प्रतिनिधित्व करने की हमारी आवश्यकता पर फिट बैठता है।

हम विधि कहते हैं withTimeAtStartOfDay दिन के समय को शून्य करने के बजाय हैं। डेलाइट सेविंग टाइम और अन्य विसंगतियों के कारण दिन का पहला क्षण नहीं हो सकता है 00:00:00।

उदाहरण कोड जोडा-टाइम 2.3 का उपयोग करना।

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

यदि आपको चाहिए, तो आप एक java.util में बदल सकते हैं।

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

Comments

मुझे उपयोग करने की आवश्यकता हैLocalDateTime

— user924

Answer 2

जावा 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());
}

अपडेट : मैंने अपने जावा यूटिलिटी क्लासेस में इन 2 तरीकों को जोड़ा है

• DateUtils.atStartOfDay
• DateUtils.atEndOfDay

यह मेवेन सेंट्रल रिपोजिटरी में है:

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

जावा 7 और इससे पहले

---

अपाचे कॉमन्स के साथ

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

अपाचे कॉमन्स के बिना

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

Comments

मैं इस दृष्टिकोण के खिलाफ सलाह देता हूं कि एज केस के मुद्दों के कारण आप समय क्षेत्र, दिन के उजाले की बचत आदि के साथ चलेंगे, जो कि टाइम लाइब्रेरी जैसे कि आपकी देखभाल करेगा।

— एडवर्ड एंडरसन

मुझे लगता है कि getStartOfDayहोना चाहिए: LocalDateTime startOfDay = localDateTime.with(LocalTime.MIN);Ie LocalTime, न कि LocalDateTime।

— कोनस्टैंटिन कुलगिन

उन मत सोचो getEndOfDay(Date date)। getStartOfDay(Date date)Java 8 सेक्शन के तरीके सही हैं, जिसका नाम है LocalDateTime.MAX और .MIN आपको एक दिन की शुरुआत और अंत में नहीं बल्कि अतीत और भविष्य में संभव तारीखों में डालते हैं। इसके बजाय मैं शुरू करने के लिए .atStartOfDay () और .plusDays (1) .atStartOfDay () और अंत के लिए minusNanos (1) का सुझाव दूंगा।

— ग्लेन मजाज़

मेथड localDateTimeToDate(LocalDateTime startOfDay)थ्रो

— एक्ससेप्शन

@GlenMazza जावा 8 समाधान का उपयोग करता LOCALTIME .max , नहीं LocalDateTime.MAX । समाधान सही है।

— फ्रेडरिक पंटुज़ा

Answer 3

getEndOfDay में, आप जोड़ सकते हैं:

calendar.set(Calendar.MILLISECOND, 999);

यद्यपि गणितीय रूप से बोलना, आप "अगले दिन की शुरुआत से पहले" कहकर एक दिन के अंत को निर्दिष्ट नहीं कर सकते।

इसलिए कहने के बजाय if(date >= getStartOfDay(today) && date <= getEndOfDay(today)), आपको कहना चाहिए if(date >= getStartOfDay(today) && date < getStartOfDay(tomorrow)):। यह एक बहुत अधिक ठोस परिभाषा है (और आपको मिलीसेकंड परिशुद्धता के बारे में चिंता करने की ज़रूरत नहीं है)।

Comments

इस उत्तर का उत्तरार्ध सबसे अच्छा तरीका है। इस दृष्टिकोण को "हाफ-ओपन" के रूप में जाना जाता है। मैं अपने जवाब में आगे बताता हूं ।

— il:

Answer 4

java.time

java.timeजावा 8 में निर्मित फ्रेमवर्क का उपयोग करना ।

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

Comments

यह उत्तर डेलाइट सेविंग टाइम (DST) जैसी विसंगतियों की उपेक्षा करता है। Local…कक्षाएं समय क्षेत्रों की कोई अवधारणा और विसंगतियों के लिए समायोजित करने के लिए है। उदाहरण के लिए, कुछ समय क्षेत्रों में आधी रात को एक डीएसटी परिवर्तन होता है, इसलिए दिन का पहला क्षण इस कोड द्वारा उत्पादित मूल्य के 01:00:00.0बजाय समय (1 बजे) पर होता है 00:00:00.0। ZonedDateTimeइसके बजाय उपयोग करें ।

— तुलसी बॉर्क

Answer 5

Java8 java.time.ZonedDateTime के साथ दिन की शुरुआत करने का अतिरिक्त तरीका LocalDateTimeकेवल इनपुट ZonedDateTime को DAYS में ट्रंक करना है:

zonedDateTimeInstance.truncatedTo( ChronoUnit.DAYS );

Answer 6

जावा 8 के लिए निम्नलिखित सिंगल लाइन स्टेटमेंट काम कर रहे हैं। इस उदाहरण में मैं यूटीसी समयक्षेत्र का उपयोग करता हूं। कृपया समय-सारणी को बदलने पर विचार करें जिसे आपने वर्तमान में उपयोग किया है।

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

यदि आउटपुट के साथ कोई समय अंतर नहीं है। प्रयत्न:ZoneOffset.ofHours(0)

Comments

यह मौजूदा उत्तरों से परे मूल्य कैसे जोड़ता है? इसके अलावा, आप समय क्षेत्र के महत्वपूर्ण मुद्दे की अनदेखी करते हैं। और UTC को निरंतर पास toInstantकरना गैरकानूनी रूप से वाक्यविन्यास और निरर्थक है।

— बेसिल बोर्ख

@BasilBourque "यह मौजूदा उत्तरों से परे मूल्य कैसे जोड़ता है?" यह है कि कैसे stackoverflow काम करता है। BTW यह सिर्फ एक टेम्पलेट है। लोग अपनी इच्छानुसार तरीके बदल सकते हैं। UTC को InInstant से गुजरना पूरी तरह से कानूनी है आप आउटपुट की जांच कर सकते हैं।

— फ्राईट K FK

Answer 7

जावा 8 या थ्रीटेनबप

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

मुझे उम्मीद है कि किसी की मदद करता है।

Comments

"एटटाइम" विधि दिन के अंत के लिए निरंतर "लोकल टाइम.मैक्स" के साथ एक बहुत अच्छा दृष्टिकोण है। अच्छा!

— श्री एंडरसन

Answer 8

मैंने इस कोड की कोशिश की और यह अच्छी तरह से काम करता है!

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

Comments

यदि आपके पास ZonedDateTimeऔर Instantआपके निपटान में कभी भी उपयोग करने की आवश्यकता नहीं है java.sql.Timestamp। वह वर्ग भयानक पुरानी विरासत वर्गों में से एक है जिसे अब java.time कक्षाओं द्वारा दबा दिया गया है । JDBC 4.2 के रूप में, हम डेटाबेस के साथ java.time ऑब्जेक्ट्स को सीधे एक्सचेंज कर सकते हैं । आपकी विरासत और आधुनिक वर्गों का मिश्रण मेरे लिए कोई मायने नहीं रखता है।

— तुलसी बॉर्क

Answer 9

एक और समाधान जो किसी भी ढांचे पर निर्भर नहीं करता है:

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 आधारित समय देता है

Answer 10

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); आपको मिलीसेकंड तक सटीकता प्रदान करता है

Comments

ये भयानक तिथि-समय की कक्षाएं सालों पहले JSR 310 में परिभाषित आधुनिक java.time कक्षाओं द्वारा दबा दी गई थीं ।

— बेसिल

@BasilBourque पैकेज java.time केवल जावा 8 में दिखाई दिया जो केवल Android N (API 26) से उपलब्ध है

— ivan8m8

@ ivan8m8 जावा- टाइम कार्यक्षमता का अधिकांश भाग थ्रीटेन-बैकपोर्ट लाइब्रेरी में जावा 6 और 7 में वापस पोर्ट किया गया है । थ्रीटेनबप लाइब्रेरी में आगे के एंड्रॉइड (<26) के लिए अनुकूलित है।

— तुलसी बोर्क

@BasilBourque लेकिन थ्रीटेन एंड्रॉइड पर एक अत्यंत अक्षम तंत्र का उपयोग करता है ।

— ivan8m8

@ ivan8m8 आप java.time , Joda-Time के पूर्ववर्ती के बारे में सोच रहे होंगे । फिर से, थ्रीटेनबैप प्रोजेक्ट देखें । मैंने उस लाइब्रेरी का उपयोग करके Android पर इस तरह की अक्षमता के बारे में नहीं सुना है।

— तुलसी बोर्क

Answer 11

मुझे पता है कि यह थोड़ा देर से है, लेकिन जावा 8 के मामले में, यदि आप ऑफसेटसेटेट का उपयोग कर रहे हैं (जो बहुत सारे फायदे प्रदान करता है, जैसे कि टाइमज़ोन, नैनोसेकंड, आदि), तो आप निम्न कोड का उपयोग कर सकते हैं:

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

Answer 12

मुझे सभी समाधानों के साथ कई असुविधाएं थीं क्योंकि मुझे त्वरित चर के प्रकार की आवश्यकता थी और टाइम ज़ोन ने हमेशा सब कुछ बदलने में हस्तक्षेप किया, फिर समाधानों के संयोजन से मैंने देखा कि यह एक अच्छा विकल्प है।

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

और हम एक परिणाम के रूप में है

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

मुझे उम्मीद है इससे आपको मदद मिली होगी

Comments

दिन वास्तव में अगले दिन के पहले क्षण के आगमन पर समाप्त होता है। आपका कोड एक दिन के अंतिम पूर्ण सेकंड में रुक जाता है, एक अरब नैनोसेकंड जो कभी रिपोर्ट नहीं किए जाते हैं। समय-समय पर परिभाषित करने के लिए हाफ-ओपन दृष्टिकोण के बारे में जानने के लिए मेरा उत्तर देखें ।

— तुलसी बोर्क

तारीख-समय के मूल्यों को संभालने के तरीके के रूप में तार को जोड़ते हुए आमतौर पर एक खराब दृष्टिकोण है। इस काम के लिए गूंगे तारों के बजाय स्मार्ट वस्तुओं का उपयोग करें। Java.time कक्षाएं सभी कार्यक्षमता आप स्ट्रिंग परिवर्तन का सहारा के बिना इस समस्या के लिए आवश्यकता होती है।

— बेसिल बॉर्क

मैंने अभी-अभी एक tl जोड़ा , मेरे उत्तर में अनुभाग दिखाया गया कि Instantवस्तुओं की एक जोड़ी के रूप में एक दिन की सीमा कैसे प्राप्त करें । युक्ति: आप अपनी कक्षा का उपयोग करने के लिए अपने प्रोजेक्ट में थ्रीटेन-एक्स्ट्रा लाइब्रेरी को जोड़ने के लिए इच्छुक हो सकते हैं Interval।

— तुलसी बॉर्क

Answer 13

मुझे लगता है कि सबसे आसान कुछ होगा:

// Joda Time

DateTime dateTime=new DateTime(); 

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

इन मिलों को तब आपकी आवश्यकता के अनुसार कैलेंडर, इंस्टेंट या लोकलडेट में परिवर्तित किया जा सकता है।

Answer 14

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