202

मैं एक तुलना विधि है कि एक java.util.Date के समय भाग को नजरअंदाज करना चाहते हैं। मुझे लगता है कि इसे हल करने के कई तरीके हैं। सबसे आसान तरीका क्या है?

java

— अर्ने एवरसन
स्रोत

212

अपडेट: जबकि उस समय जोडा टाइम एक अच्छी सिफारिश थी, java.timeजहां संभव हो वहां जावा 8+ से लाइब्रेरी का उपयोग करें ।

मेरी प्राथमिकता जोडा समय का उपयोग करना है जो इसे अविश्वसनीय रूप से आसान बनाता है:

DateTime first = ...;
DateTime second = ...;

LocalDate firstDate = first.toLocalDate();
LocalDate secondDate = second.toLocalDate();

return firstDate.compareTo(secondDate);

संपादित करें: जैसा कि टिप्पणियों में कहा गया है, यदि आप इसका उपयोग करते हैं तो DateTimeComparator.getDateOnlyInstance()यह और भी आसान है :)

// TODO: consider extracting the comparator to a field.
return DateTimeComparator.getDateOnlyInstance().compare(first, second);

("Joda Time का उपयोग करें" लगभग सभी SO प्रश्नों का आधार है जो इसके बारे में पूछते हैं java.util.Dateया java.util.Calendarयह पूरी तरह से बेहतर API है। यदि आप तारीखों / समय के साथ कुछ भी महत्वपूर्ण कर रहे हैं , तो आपको वास्तव में इसका उपयोग करना चाहिए यदि आप संभवतः कर सकते हैं।)

यदि आप बिल्ट इन एपीआई का उपयोग करने के लिए पूरी तरह से मजबूर हैं , तो आपको Calendarउपयुक्त तिथि के साथ और उचित समय क्षेत्र का उपयोग करके एक उदाहरण बनाना चाहिए । तब आप प्रत्येक कैलेंडर में प्रत्येक क्षेत्र को घंटे, मिनट, सेकंड और मिलीसेकंड से 0 तक सेट कर सकते हैं और परिणामी समय की तुलना कर सकते हैं। हालांकि निश्चित रूप से Joda समाधान के साथ तुलना icky :)

समय क्षेत्र हिस्सा महत्वपूर्ण है: java.util.Dateहै हमेशा यूटीसी पर आधारित है। ज्यादातर मामलों में जहां मुझे एक तारीख में दिलचस्पी रही है, वह एक विशिष्ट समय क्षेत्र में एक तारीख है । यह अपने आप ही आपको उपयोग करने के लिए मजबूर कर देगा Calendarया जबड़ा समय (जब तक आप स्वयं समय क्षेत्र का हिसाब नहीं देना चाहेंगे, जिसकी मैं अनुशंसा नहीं करता हूं।)

Android डेवलपर्स के लिए त्वरित संदर्भ

//Add joda library dependency to your build.gradle file
dependencies {
     ...
     implementation 'joda-time:joda-time:2.9.9'
}

नमूना कोड (उदाहरण)

DateTimeComparator dateTimeComparator = DateTimeComparator.getDateOnlyInstance();

Date myDateOne = ...;
Date myDateTwo = ...;

int retVal = dateTimeComparator.compare(myDateOne, myDateTwo);

if(retVal == 0)
   //both dates are equal
else if(retVal < 0)
   //myDateOne is before myDateTwo
else if(retVal > 0)
   //myDateOne is after myDateTwo

— जॉन स्कीट
स्रोत

28

जैसा कि जॉन कहते हैं "जोडा टाइम का उपयोग करें" लगभग सभी एसओ प्रश्नों का आधार है जो java.util.Date या java.util के बारे में पूछते हैं। कैलेन्डर मुझे हमेशा लगता है कि सबसे पहले उपयोगकर्ता के प्रश्न के आधार पर एक ठोस उत्तर देना सबसे अच्छा है, कम से कम यह दिखाने के लिए कि जावा रास्ता करने के लिए कितना कठिन हो सकता है। और इसके बाद जोडा का उपयोग करने का सुझाव दिया ...

— जुआनज़े

13

@ जुआनज़े: एक दर्दनाक एपीआई में कुछ ठीक से कैसे करें, इसके बारे में ठीक से काम करने की आवश्यकता है, जो परिभाषा के अनुसार दर्दनाक है। मैं उस समय को और अधिक उत्पादक बनाने में

— बिताऊंगा

1

@ MetroidFan2002: लोकल डेट डेटनाइट की तुलना में एक बेहतर विकल्प है, क्योंकि यह अधिक अभिव्यंजक है - और सभी दिनों में आधी रात नहीं है ...

— जॉन स्कीट

2

@dertoni: ज़रूर - ब्राज़ील में, जब दिन के समय की बचत के कारण घड़ियाँ आगे बढ़ती हैं, जो दिन की शुरुआत में होती है ... तो एक घड़ी 23:59:58, 23:59:59, 01:00 बजे पढ़ेगी : 00, 01:00:01 आदि

— जॉन स्कीट

8

क्या DateTimeComparator.getDateOnlyInstance ()

— Emil

125

अपाचे कॉमन्स-लैंग लगभग सर्वव्यापी है। तो इस बारे में क्या?

if (DateUtils.isSameDay(date1, date2)) {
    // it's same
} else if (date1.before(date2)) {
   // it's before
} else {
   // it's after
}

— आंद्रे
स्रोत

संस्करण 2.6 में एक truncatedCompareTo फ़ंक्शन शामिल है commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/…

— shonky linux उपयोगकर्ता

2

अफसोस की बात है कि तारीखों को बर्दाश्त नहीं करता है

— पावेल निदोबा

दोस्तों, आजकल हमारे पास Java 8 stackoverflow.com/a/35411693/259237

— André

मैं इस तरह से पहले के उपयोग की अनुशंसा नहीं करता हूं क्योंकि अगर पहली या दूसरी तारीख वाली वस्तु को टाइमस्टैम्प से दागा गया और मीलोंकॉन्ड किया गया है, और दूसरा एक सामान्य तिथि वस्तु है जिससे आपको परेशानी होगी क्योंकि, डेटस्टैम्प स्टोर से डेट एक अलग भाग में दोनों तिथियों के बराबर होने पर भी मिलिसेकंड की वस्तु अंतर देती है।

— जिनी

दुर्भाग्य से, अपाचे यह 1.3 बिलियन से अधिक एंड्रॉइड डिवाइस पर नहीं है, और यह केवल एक उपयोग-मामले के लिए निर्भर करने के लिए एक विशाल पुस्तकालय है। मुझे कुछ और चाहिए: /

— milosmns

58

यदि आप वास्तव में java.util.Date का उपयोग करना चाहते हैं, तो आप कुछ इस तरह करेंगे:

public class TimeIgnoringComparator implements Comparator<Date> {
  public int compare(Date d1, Date d2) {
    if (d1.getYear() != d2.getYear()) 
        return d1.getYear() - d2.getYear();
    if (d1.getMonth() != d2.getMonth()) 
        return d1.getMonth() - d2.getMonth();
    return d1.getDate() - d2.getDate();
  }
}

या, के बजाय एक कैलेंडर का उपयोग कर (पसंदीदा, क्योंकि getYear () और ऐसे पदावनत हैं)

public class TimeIgnoringComparator implements Comparator<Calendar> {
  public int compare(Calendar c1, Calendar c2) {
    if (c1.get(Calendar.YEAR) != c2.get(Calendar.YEAR)) 
        return c1.get(Calendar.YEAR) - c2.get(Calendar.YEAR);
    if (c1.get(Calendar.MONTH) != c2.get(Calendar.MONTH)) 
        return c1.get(Calendar.MONTH) - c2.get(Calendar.MONTH);
    return c1.get(Calendar.DAY_OF_MONTH) - c2.get(Calendar.DAY_OF_MONTH);
  }
}

— Jorn
स्रोत

1

दूसरी विधि में आप अपने कुछ संदर्भों को अपडेट करना भूल गए, d1, d2 से c1, c2 तक।

— stivlo

1

उस विवरण को ठीक करने के बाद आपका कोड अच्छी तरह से काम करता है: मैंने बड़े पैमाने पर इकाई का परीक्षण किया है। मैंने तिथियों से एक कैलेंडर बनाने के लिए कदम जोड़ा है, और अपने नए बनाए गए github प्रोजेक्ट org.obliquid.helpers में आपके कोड का उपयोग किया है , धन्यवाद।

— 18

किसी भी बाहरी पुस्तकालय का उपयोग किए बिना मीठा, अच्छा समाधान।

— 4gus71n

1

इन सभी विधियों को पदावनत किया जाता है। क्या इसका किसी तरह का असर हो सकता है?

— प्रणव महाजन

36

मेरी प्राथमिकता उपयोग करने के लिए किया जाएगा Joda के पुस्तकालय insetad java.util.Date, सीधे रूप में Joda दिनांक और समय (देखें के बीच एक अंतर बना देता है YearMonthDay और दिनांक समय वर्ग)।

हालाँकि, यदि आप उपयोग करना चाहते हैं, तो java.util.Dateमैं एक उपयोगिता विधि लिखने का सुझाव दूंगा; जैसे

public static Date setTimeToMidnight(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();
}

— अदाम्सकी
स्रोत

1

Joda-Time YearMonthDay, LocalDate के पक्ष में चित्रित किया गया है। इसके अलावा, यदि समय क्षेत्र में दिन के उजाले की बचत के कारण मध्याह्न 00:00 नहीं है, तो कैलेंडर के कोड में समस्याएं होंगी।

— JodaStephen

1

यह समय के 100% काम नहीं करता है। एक उपयोग का मामला था जहां मैंने ऐसा किया था और Calendar.getTime () अभी भी पैरामीटर तिथि के रूप में सेट किए गए घंटों के साथ समय लौटाएगा। खेतों को खाली करने के लिए सबसे अच्छा है और केवल वर्ष, महीने और दिन निर्धारित करते हैं।

— जोनाथन ड्रापो

31

इस विकल्प पर कोई राय?

SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
sdf.format(date1).equals(sdf.format(date2));

— रॉबर्ट ब्राउन
स्रोत

1

मुझे नहीं लगता कि यह काम करेगा, भले ही स्ट्रिंग्स को परिवर्तित करना एक अच्छा विचार था। ==ऑपरेटर जरूरी वापस नहीं करता trueबराबर स्ट्रिंग्स (उपयोग के लिए equals())। आप निश्चित रूप से आपके द्वारा उल्लिखित अन्य तुलना ऑपरेटरों का उपयोग नहीं कर सकते हैं।

— ०१:५५

1

आह हाँ - मेरी रूबी मेरे जावा को बर्बाद कर रही है! स्ट्रिंग्स को किलों में परिवर्तित कर सकते हैं हालांकि <,> आदि के लिए

— रॉबर्ट ब्राउन

Joda का उपयोग ध्वनि तरीका है, लेकिन यह सुरुचिपूर्ण है!

— आर्ने एवरटसन

यह सभी के लिए काम नहीं करेगा, लेकिन यह बहुत सरल और हल्का है; एक अच्छा विकल्प जब अन्य लिबास उपलब्ध नहीं हैं।

— जैकब मार्बल

तिथियों का क्रम प्राप्त करने के लिए, आप उपयोग भी कर सकते हैं sdf.format(date1).compareTo(sdf.format(date2));।

— ओले वीवी

18

यदि आप दो तिथियों के केवल महीने, दिन और वर्ष की तुलना करना चाहते हैं, तो निम्नलिखित कोड मेरे लिए काम करते हैं:

SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
sdf.format(date1).equals(sdf.format(date2));

धन्यवाद रॉब।

— Dellanio
स्रोत

13

मैं भी Joda Time पसंद करता हूँ , लेकिन यहाँ एक विकल्प है:

long oneDay = 24 * 60 * 60 * 1000
long d1 = first.getTime() / oneDay
long d2 = second.getTime() / oneDay
d1 == d2

संपादित करें

यदि आप UTC के अलावा किसी अन्य विशिष्ट समयक्षेत्र के लिए दिनांक की तुलना करने की आवश्यकता है, तो मैं UTC बात को नीचे रखता हूँ। यदि आपके पास ऐसी कोई आवश्यकता है, हालांकि, तो मैं वास्तव में जोडा के लिए जाने की सलाह देता हूं।

long oneDay = 24 * 60 * 60 * 1000
long hoursFromUTC = -4 * 60 * 60 * 1000 // EST with Daylight Time Savings
long d1 = (first.getTime() + hoursFromUTC) / oneDay
long d2 = (second.getTime() + hoursFromUTC) / oneDay
d1 == d2

— डैनियल सी। सोबरल
स्रोत

मैंने कहा कि मैं जोडा टाइम का उपयोग करूंगा, लेकिन यह एक अच्छा बिंदु है। मैं केवल इस तरह के कम रणनीति का सहारा लेता हूं जब मुझे वास्तव में टीके में दिलचस्पी नहीं होती है।

— डैनियल सी। सोबराल

विभाजन से बचा जा सकता है:Math.abs(second.getTime() - first.getTime()) < 1000L*60*60*24

— वडज़िम

@Vadzim इसे बनाओ < oneDay।

— डैनियल सी। सोबराल

2

@Vadzim, कि अगर तारीखें 1 दिन से कम हो तो ही जांच होती है। जरूरी नहीं कि वे एक ही दिन हों।

— अरहंत

@ वरहंत, हाँ। यह पर्याप्त हो सकता है जब दूसरी तारीख हमेशा मध्यरात्रि-संरेखित होती है।

— वडज़िम

12

tl; डॉ

myJavaUtilDate1.toInstant()
               .atZone( ZoneId.of( "America/Montreal" ) )
               .toLocalDate()
               .isEqual (
                   myJavaUtilDate2.toInstant()
                                  .atZone( ZoneId.of( "America/Montreal" ) )
                                  .toLocalDate()
               )

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

परेशान पुरानी विरासत तिथि-समय वर्गों जैसे Date& से बचें Calendar, अब java.time कक्षाओं द्वारा इसे दबा दिया गया।

Java.time का उपयोग करना

एक java.util.DateUTC में समय रेखा पर एक पल के प्रतिनिधित्व करता है। Java.time में बराबर है Instant। आप विरासत वर्ग में जोड़े गए नए तरीकों का उपयोग करके परिवर्तित कर सकते हैं।

Instant instant1 = myJavaUtilDate1.toInstant();
Instant instant2 = myJavaUtilDate2.toInstant();

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

के रूप में , या , के प्रारूप में एक उचित समय क्षेत्र नाम निर्दिष्ट करें । कभी इस तरह के रूप में 3-4 पत्र संक्षिप्त नाम का उपयोग या के रूप में वे कर रहे हैं नहीं सच समय क्षेत्र, नहीं मानकीकृत, और यहां तक कि अद्वितीय नहीं (!)।continent/regionAmerica/MontrealAfrica/CasablancaPacific/AucklandESTIST

ZoneId z = ZoneId.of( "America/Montreal" );

पाने के ZoneIdलिए आवेदन करें ।InstantZonedDateTime

ZonedDateTime zdt1 = instant1.atZone( z );
ZonedDateTime zdt2 = instant2.atZone( z );

LocalDateवर्ग समय के दिन और समय क्षेत्र के बिना बिना एक दिनांक-केवल मूल्य का प्रतिनिधित्व करता। हम समय के हिस्से को प्रभावी ढंग से समाप्त करते हुए, ए LocalDateसे निकाल सकते ZonedDateTimeहैं।

LocalDate localDate1 = zdt1.toLocalDate();
LocalDate localDate2 = zdt2.toLocalDate();

अब की तुलना, जैसे तरीकों का उपयोग कर isEqual, isBeforeऔर isAfter।

Boolean sameDate = localDate1.isEqual( localDate2 );

इस कोड को IdeOne.com पर लाइव देखें ।

तत्काल 1: 2017-03-25T04: 13: 10.971Z | इंस्टेंट 2: 2017-03-24T22: 13: 10.972Z

zdt1: 2017-03-25T00: 13: 10.971-04: 00 [अमेरिका / मॉन्ट्रियल] | zdt2: 2017-03-24T18: 13: 10.972-04: 00 [अमेरिका / मॉन्ट्रियल]

localDate1: 2017-03-25 | localDate2: 2017-03-24

वहीडेट: झूठा

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

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

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

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

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

जावा एसई 8 और एसई 9 और बाद में
- निर्मित।
- बंडल के कार्यान्वयन के साथ मानक जावा एपीआई का एक हिस्सा।
- जावा 9 में कुछ छोटी विशेषताएं और सुधार शामिल हैं।
जावा एसई 6 और एसई 7
- जावा-टाइम की अधिकांश कार्यक्षमता थ्री-बैक-बैकपोर्ट में जावा 6 और 7 में वापस पोर्ट की गई है ।
एंड्रॉयड
- ThreeTenABP परियोजना adapts ThreeTen-backport विशेष रूप से Android के लिए (जैसा कि ऊपर उल्लेख)।
- देखें कि थ्रीटेबैप का उपयोग कैसे करें… ।

ThreeTen-अतिरिक्त परियोजना अतिरिक्त कक्षाओं के साथ java.time फैली हुई है। यह परियोजना java.time के लिए भविष्य के अतिरिक्त के लिए एक साबित जमीन है। आप यहाँ कुछ उपयोगी वर्गों जैसे मिल सकता है Interval, YearWeek, YearQuarter, और अधिक ।

— तुलसी Bourque
स्रोत

7

पहले से ही अपाचे कॉमन्स-बर्तन का उल्लेख किया गया है :

org.apache.commons.lang.time.DateUtils.truncate(date, Calendar.DAY_OF_MONTH)

आपको बिना समय के, केवल दिनांक वाली वस्तु देता है, और आप इसकी तुलना कर सकते हैं Date.compareTo

— दानूबियन नाविक
स्रोत

6

मुझे डर है कि दो तारीखों की तुलना करने का कोई तरीका नहीं है जिसे "आसान" या "सरल" कहा जा सकता है।

किसी भी प्रकार की कम सटीकता के साथ दो समय के उदाहरणों की तुलना करते समय (जैसे कि तारीखों की तुलना करना), आपको हमेशा इस बात का ध्यान रखना चाहिए कि समय क्षेत्र तुलना को कैसे प्रभावित करता है।

यदि date1एक घटना को निर्दिष्ट कर रहा है जो +2 टाइमज़ोन date2में हुई है और ईएसटी में हुई एक घटना को निर्दिष्ट कर रही है, उदाहरण के लिए, आपको तुलना के निहितार्थ को ठीक से समझने के लिए ध्यान रखना चाहिए।

क्या आपका उद्देश्य यह पता लगाने का है कि क्या दोनों घटनाएं एक ही कैलेंडर तिथि में अपने-अपने समय क्षेत्र में घटित हुई हैं? या क्या आपको यह जानने की जरूरत है कि क्या दो तिथियां एक विशिष्ट समय क्षेत्र (यूटीसी या आपके स्थानीय टीएजी में एक ही कैलेंडर तिथि में आती हैं, उदाहरण के लिए)।

एक बार जब आप समझ जाते हैं कि यह वास्तव में क्या है जिसकी आप तुलना करने की कोशिश कर रहे हैं, तो यह उचित समय क्षेत्र में वर्ष-माह-तारीख ट्रिपल प्राप्त करने की बात है और तुलना करें।

जोडा समय वास्तविक तुलना ऑपरेशन को अधिक साफ-सुथरा बना सकता है, लेकिन तुलना के शब्दार्थ अभी भी कुछ हैं जो आपको स्वयं पता लगाने की आवश्यकता है।

— रोलैंड टेप्प
स्रोत

6

यदि आप जावा 8 का उपयोग कर रहे हैं, तो आपको java.time.*तारीखों की तुलना करने के लिए कक्षाओं का उपयोग करना चाहिए - यह विभिन्न java.util.*वर्गों को पसंद है

जैसे; https://docs.oracle.com/javase/8/docs/api/java/time/LocalDate.html

LocalDate date1 = LocalDate.of(2016, 2, 14);
LocalDate date2 = LocalDate.of(2015, 5, 23);
date1.isAfter(date2);

— लोरकन ओ'नील
स्रोत

5

यदि आप बिना समय के केवल दो तिथियों की तुलना करना चाहते हैं, तो निम्नलिखित कोड आपकी सहायता कर सकते हैं:

final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
Date dLastUpdateDate = dateFormat.parse(20111116);
Date dCurrentDate = dateFormat.parse(dateFormat.format(new Date()));
if (dCurrentDate.after(dLastUpdateDate))
{
   add your logic
}

— प्रीतेश शाह
स्रोत

यह रोब के जवाब के समान है । मुझे लगता है कि जोर्न का समाधान बेहतर है क्योंकि इसमें स्ट्रिंग्स के लिए एक गोल-यात्रा शामिल नहीं है और उसी चीज को पूरा करना चाहिए।

— Rup

4

यहाँ इस ब्लॉग से एक समाधान है: http://brigitzblog.blogspot.com/2011/10/java-compare-d.net.html

long milliseconds1 = calendar1.getTimeInMillis();
long milliseconds2 = calendar2.getTimeInMillis();
long diff = milliseconds2 - milliseconds1;
long diffDays = diff / (24 * 60 * 60 * 1000);
System.out.println("Time in days: " + diffDays  + " days.");

यानी आप देख सकते हैं कि मिलीसेकंड में समय का अंतर एक दिन की लंबाई से कम है या नहीं।

— Wilbert
स्रोत

4

यह नमूना जाँच करेगा कि दो तारीखें एक-दूसरे के 24 घंटों के भीतर हैं, लेकिन जरूरी नहीं कि यदि वे दोनों एक ही तिथि पर हों, तो मध्यरात्रि को संभव है। इसके बजाय मिलिस के दोनों सेटों को MILLIS_IN_DAY द्वारा विभाजित करना और परिणाम की तुलना करना बेहतर होगा, लेकिन यह केवल UTC के लिए सटीक होगा न कि स्थानीय समय के लिए।

— Rup

4

`

SimpleDateFormat sdf= new SimpleDateFormat("MM/dd/yyyy")

   Date date1=sdf.parse("03/25/2015");



  Date currentDate= sdf.parse(sdf.format(new Date()));

   return date1.compareTo(currentDate);

`

— जाकिर
स्रोत

3

मुझे नहीं पता कि यह नई सोच है या फिर, लेकिन मैं आपको दिखाता हूं जैसे मैंने किया था

SimpleDateFormat dtf = new SimpleDateFormat("dd/MM/yyyy");
Date td_date = new Date();
String first_date = dtf.format(td_date);    //First seted in String 
String second_date = "30/11/2020";          //Second date you can set hear in String

String result = (first_date.equals(second_date)) ? "Yes, Its Equals":"No, It is not Equals";
System.out.println(result);

— 13hola
स्रोत

3

केवल YEAR संपत्ति के साथ संयोजन में DAY_OF_YEAR की जाँच करें

boolean isSameDay = 
firstCal.get(Calendar.YEAR) == secondCal.get(Calendar.YEAR) &&
firstCal.get(Calendar.DAY_OF_YEAR) == secondCal.get(Calendar.DAY_OF_YEAR)

संपादित करें:

अब हम कोटलिन एक्सटेंशन कार्यों की शक्ति का उपयोग कर सकते हैं

fun Calendar.isSameDay(second: Calendar): Boolean {

    return this[Calendar.YEAR] == second[Calendar.YEAR] && this[Calendar.DAY_OF_YEAR] == second[Calendar.DAY_OF_YEAR]
}

fun Calendar.compareDatesOnly(other: Calendar): Int {

    return when {
        isSameDay(other) -> 0
        before(other) -> -1
        else -> 1
    }
}

— साइमन के। गेर्गेस
स्रोत

यह गलत है क्योंकि विभिन्न वर्षों के साथ तिथियों में वर्ष 2015-01-01 और 2016-01-01 के लिए वर्ष का एक ही दिन हो सकता है।

— नेल्सन एल्डोरो

@nelsoneldoro आपकी टिप्पणी के लिए धन्यवाद, वर्ष के लिए एक चेक जोड़ना भूल गया, अब यह ठीक होना चाहिए।

— साइमन के। गेर्गेस

2

Java 8 में आप LocalDate का उपयोग कर सकते हैं जो कि Joda Time से बहुत मिलता जुलता है।

— habsq
स्रोत

2

public Date saveDateWithoutTime(Date date) {
    Calendar calendar = Calendar.getInstance();

    calendar.setTime( date );
    calendar.set(Calendar.HOUR_OF_DAY, 0);
    calendar.set(Calendar.HOUR, 0);
    calendar.set(Calendar.MINUTE, 0);
    calendar.set(Calendar.SECOND, 0);
    calendar.set(Calendar.MILLISECOND, 0);

    return calendar.getTime();
}

यह आपको समय पर विचार किए बिना तारीखों की तुलना करने में मदद करेगा।

— फातिमा किमी
स्रोत

1

SimpleDateFormat के getDateInstance का उपयोग करके, हम बिना समय के केवल दो दिनांक ऑब्जेक्ट की तुलना कर सकते हैं। नीचे दिए गए कोड को निष्पादित करें।

public static void main(String[] args) {        
        Date date1  = new Date();
        Date date2  = new Date();
        DateFormat dfg = SimpleDateFormat.getDateInstance(DateFormat.DATE_FIELD);
        String dateDtr1 = dfg.format(date1);
        String dateDtr2 = dfg.format(date2);
        System.out.println(dateDtr1+" : "+dateDtr2);
        System.out.println(dateDtr1.equals(dateDtr2));  

    }

— सेंथिल एेश्वरमूर्ति
स्रोत

1

Http://mvnrepository.com/artifact/commons-lang/commons-lang का उपयोग करना

Date date1 = new Date();

Date date2 = new Date();

if (DateUtils.truncatedCompareTo(date1, date2, Calendar.DAY_OF_MONTH) == 0)
    // TRUE
else
    // FALSE

— फेडेरिको ट्रेमैन
स्रोत

3

या बस DateUtils.isSameDay(date1, date2)।

— ओलीगॉगर

1

यहाँ और मेरे संरक्षक मार्गदर्शन के जवाबों के आधार पर एक और सरल तुलना विधि

public static int compare(Date d1, Date d2) {
    Calendar c1 = Calendar.getInstance();
    Calendar c2 = Calendar.getInstance();
    c1.setTime(d1);
    c1.set(Calendar.MILLISECOND, 0);
    c1.set(Calendar.SECOND, 0);
    c1.set(Calendar.MINUTE, 0);
    c1.set(Calendar.HOUR_OF_DAY, 0);
    c2.setTime(d2);
    c2.set(Calendar.MILLISECOND, 0);
    c2.set(Calendar.SECOND, 0);
    c2.set(Calendar.MINUTE, 0);
    c2.set(Calendar.HOUR_OF_DAY, 0);
    return c1.getTime().compareTo(c2.getTime());
  }

EDIT : @Jonathan Drapeau के अनुसार, ऊपर दिया गया कोड कुछ मामलों में विफल हो जाता है (मैं उन मामलों को देखना चाहता हूं, कृपया) और उन्होंने मुझे समझाते हुए निम्नलिखित सुझाव दिए:

public static int compare2(Date d1, Date d2) {
    Calendar c1 = Calendar.getInstance();
    Calendar c2 = Calendar.getInstance();
    c1.clear();
    c2.clear();
    c1.set(Calendar.YEAR, d1.getYear());
    c1.set(Calendar.MONTH, d1.getMonth());
    c1.set(Calendar.DAY_OF_MONTH, d1.getDay());
    c2.set(Calendar.YEAR, d2.getYear());
    c2.set(Calendar.MONTH, d2.getMonth());
    c2.set(Calendar.DAY_OF_MONTH, d2.getDay());
    return c1.getTime().compareTo(c2.getTime());
}

कृपया ध्यान दें कि, दिनांक वर्ग का वंचित कारण है क्योंकि यह अंतर्राष्ट्रीयकरण के लिए उत्तरदायी नहीं था। इसके बजाय कैलेंडर वर्ग का उपयोग किया जाता है!

— अब्देलर्रहमान ऐली
स्रोत

यह समय के 100% काम नहीं करता है। एक उपयोग का मामला था जहां मैंने ऐसा किया था और Calendar.getTime () अभी भी पैरामीटर तिथि के रूप में सेट किए गए घंटों के साथ समय लौटाएगा। खेतों को खाली करने के लिए सबसे अच्छा है और केवल वर्ष, महीने और दिन निर्धारित करते हैं।

— जोनाथन ड्रापो

@JonathanDrapeau, यह मुझे लगता है कि आप एक स्पष्ट समय क्षेत्र नहीं लेने के परिणामस्वरूप चला सकते हैं। निश्चित रूप से बेहतर समय क्षेत्र को स्पष्ट करने की तुलना में स्पष्ट getXxxतरीकों का उपयोग करें Date।

— ओले वीवी

1

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

चूँकि आपका प्रश्न इस बारे में बिल्कुल स्पष्ट नहीं है, इसलिए मैं यह मान रहा हूँ कि आपके पास एक ऐसा क्षेत्र है जिसमें एक क्षेत्र है जिसका समय और कार्यान्वयन में एक बिंदु है Comparable, और आप चाहते हैं कि आपकी वस्तुओं का प्राकृतिक क्रम तिथि तक हो, लेकिन समय नहीं उस क्षेत्र में। उदाहरण के लिए:

public class ArnesClass implements Comparable<ArnesClass> {

    private static final ZoneId arnesTimeZone = ZoneId.systemDefault();

    private Instant when;

    @Override
    public int compareTo(ArnesClass o) {
        // question is what to put here
    }

}

जावा 8 `java.time`कक्षाएं

मैं से अपने उदाहरण मैदान के प्रकार को बदलने की स्वतंत्रता ले लिया है Dateकरने के लिए Instant, जावा 8. में इसी वर्ग मैं के उपचार के लिए वापसी का वादा Dateनीचे। मैंने एक टाइम ज़ोन स्थिरांक भी जोड़ा है। आप इसे करने के लिए सेट कर सकते हैं ZoneOffset.UTCया ZoneId.of("Europe/Stockholm")या आप क्या लगता है उचित (एक करने के लिए इसे स्थापित करने ZoneOffsetका काम करता है क्योंकि ZoneOffsetका एक उपवर्ग हैZoneId )।

मैंने जावा 8 कक्षाओं का उपयोग करके समाधान दिखाने के लिए चुना है। आपने सबसे सरल तरीका पूछा, है ना? :-) यहां वह compareToविधि है जो आपने मांगी थी:

public int compareTo(ArnesClass o) {
    LocalDate dateWithoutTime = when.atZone(arnesTimeZone).toLocalDate();
    LocalDate otherDateWithoutTime = o.when.atZone(arnesTimeZone).toLocalDate();
    return dateWithoutTime.compareTo(otherDateWithoutTime);
}

यदि आपको कभी भी समय की आवश्यकता नहीं है when, तो यह निश्चित रूप से आसान है whenएक घोषित करनाLocalDate और सभी रूपांतरणों को छोड़ना । फिर हमें अब समय क्षेत्र के बारे में चिंता करने की आवश्यकता नहीं है।

अब मान लीजिए कि किसी कारण से आप अपने whenक्षेत्र की घोषणा नहीं कर सकते हैं Instantया आप इसे पुराने जमाने का रखना चाहते हैं Date। यदि आप अभी भी जावा 8 का उपयोग कर सकते हैं Instant, तो इसे पहले रूपांतरित करें , फिर पहले की तरह करें:

    LocalDate dateWithoutTime = when.toInstant().atZone(arnesTimeZone).toLocalDate();

इसी तरह के लिए o.when।

कोई जावा 8 नहीं?

यदि आप जावा 8 का उपयोग नहीं कर सकते हैं, तो दो विकल्प हैं:

पुरानी कक्षाओं में से किसी एक का उपयोग करके इसे हल करें Calendarया SimpleDateFormat।
जावा 6 और 7 को जावा 8 दिनांक और समय वर्गों के बैकपोर्ट का उपयोग करें, फिर ऊपर जैसा करें। मैं नीचे एक लिंक शामिल करता हूं। JodaTime का उपयोग न करें। JodaTime शायद एक अच्छा सुझाव था, जब यह सिफारिश करने वाले उत्तर लिखे गए थे; लेकिन JodaTime अब रखरखाव मोड में है, इसलिए थ्रीटैन बैकपोर्ट एक बेहतर और भविष्य में बेहतर विकल्प है।

पुराने ढंग के हैं

Adamski का जवाब आपको दिखाता है कि कक्षा Dateका उपयोग करके समय भाग को कैसे पट्टी करना है Calendar। मेरा सुझाव है कि आप अपने इच्छित समय क्षेत्र के लिए उदाहरण getInstance(TimeZone)प्राप्त करने के लिए उपयोग करें Calendar। एक विकल्प के रूप में आप जोर्न के उत्तर के उत्तरार्ध से विचार का उपयोग कर सकते हैं ।

उपयोग करना SimpleDateFormatवास्तव में एक वस्तु के Calendarबाद से उपयोग करने का एक अप्रत्यक्ष तरीका है । हालाँकि, आपको सीधे उपयोग करने की तुलना में यह कम तकलीफदेह लग सकता है:SimpleDateFormatCalendarCalendar

private static final TimeZone arnesTimeZone = TimeZone.getTimeZone("Europe/Stockholm");
private static final DateFormat formatter = new SimpleDateFormat("yyyyMMdd");
static {
    formatter.setTimeZone(arnesTimeZone);
}

private Date when;

@Override
public int compareTo(ArnesClass o) {
    return formatter.format(when).compareTo(formatter.format(o.when));
}

यह रॉब के जवाब से प्रेरित था ।

समय क्षेत्र निर्भरता

हमें एक विशिष्ट समय क्षेत्र क्यों चुनना है? यह कहें कि हम दो बार तुलना करना चाहते हैं कि UTC में 24 मार्च 0:00 (मध्यरात्रि) और 12:00 (दोपहर) हैं। यदि आप सीईटी (कहते हैं, यूरोप / पेरिस) में करते हैं, तो वे 24 मार्च को दोपहर 1 बजे और 1 बजे हैं, यानी एक ही तारीख। न्यूयॉर्क (ईस्टर्न डेलाइट टाइम) में, वे 23 मार्च को 20:00 और 24 मार्च को 8:00 बजे हैं, यही तारीख नहीं है। तो इससे फर्क पड़ता है कि आप किस टाइम जोन को चुनते हैं। अगर आप सिर्फ कंप्यूटर के डिफॉल्ट पर भरोसा करते हैं, तो आप आश्चर्य में पड़ सकते हैं जब कोई इस वैश्विक दुनिया में किसी दूसरे स्थान पर कंप्यूटर पर अपना कोड चलाने की कोशिश करता है।

संपर्क

थ्रीटेन बैकपोर्ट से लिंक, जावा 8 की तारीख और जावा 6 और 7 के लिए समय कक्षाएं: http://www.threeten.org/threetenbp/ ।

— ओले वी.वी.
स्रोत

0

मेरा प्रस्ताव:

    Calendar cal = Calendar.getInstance();
    cal.set(1999,10,01);   // nov 1st, 1999
    cal.set(Calendar.AM_PM,Calendar.AM);
    cal.set(Calendar.HOUR,0);
    cal.set(Calendar.MINUTE,0);
    cal.set(Calendar.SECOND,0);
    cal.set(Calendar.MILLISECOND,0);

    // date column in the Thought table is of type sql date
    Thought thought = thoughtDao.getThought(date, language);

    Assert.assertEquals(cal.getTime(), thought.getDate());

— जीन-पियरे श्नाइडर
स्रोत

0

अपाचे कॉमन्स का उपयोग आप कर सकते हैं:

import org.apache.commons.lang3.time.DateUtils

DateUtils.truncatedEquals(first, second, Calendar.DAY_OF_MONTH)

— यूनिफाई
स्रोत

0

public static Date getZeroTimeDate(Date fecha) {
    Date res = fecha;
    Calendar calendar = Calendar.getInstance();

    calendar.setTime( fecha );
    calendar.set(Calendar.HOUR_OF_DAY, 0);
    calendar.set(Calendar.MINUTE, 0);
    calendar.set(Calendar.SECOND, 0);
    calendar.set(Calendar.MILLISECOND, 0);

    res = calendar.getTime();

    return res;
}

Date currentDate = getZeroTimeDate(new Date());// get current date

यह इस समस्या को हल करने का सबसे सरल तरीका है।

— rana_sadam
स्रोत

0

मैंने इसे टाइमस्टैम्प द्वारा तुलना करके हल किया:

    Calendar last = Calendar.getInstance();

    last.setTimeInMillis(firstTimeInMillis);

    Calendar current = Calendar.getInstance();

    if (last.get(Calendar.DAY_OF_MONTH) != current.get(Calendar.DAY_OF_MONTH)) {
        //not the same day
    }

मैं Joda Time का उपयोग करने से बचता हूं क्योंकि Android पर एक विशाल स्थान का उपयोग किया जाता है। आकर महत्त्व रखता है। ;)

— ऑस्कर जोस्यू अलवरेज़
स्रोत

0

जावा 8 और इंस्टेंट का उपयोग करते हुए एक और समाधान, ट्रंकटेटो विधि का उपयोग कर रहा है

निर्दिष्ट इकाई को काटे गए इस त्वरित की एक प्रति लौटाता है।

उदाहरण:

@Test
public void dateTruncate() throws InterruptedException {
    Instant now = Instant.now();
    Thread.sleep(1000*5);
    Instant later = Instant.now();
    assertThat(now, not(equalTo(later)));
    assertThat(now.truncatedTo(ChronoUnit.DAYS), equalTo(later.truncatedTo(ChronoUnit.DAYS)));
}

— rince
स्रोत

0

// Create one day 00:00:00 calendar
int oneDayTimeStamp = 1523017440;
Calendar oneDayCal = Calendar.getInstance();
oneDayCal.setTimeInMillis(oneDayTimeStamp * 1000L);
oneDayCal.set(Calendar.HOUR_OF_DAY, 0);
oneDayCal.set(Calendar.MINUTE, 0);
oneDayCal.set(Calendar.SECOND, 0);
oneDayCal.set(Calendar.MILLISECOND, 0);

// Create current day 00:00:00 calendar
Calendar currentCal = Calendar.getInstance();
currentCal.set(Calendar.HOUR_OF_DAY, 0);
currentCal.set(Calendar.MINUTE, 0);
currentCal.set(Calendar.SECOND, 0);
currentCal.set(Calendar.MILLISECOND, 0);

if (oneDayCal.compareTo(currentCal) == 0) {
    // Same day (excluding time)
}

— yaslam
स्रोत

धन्यवाद! हालांकि पहले से ही एक ही दृष्टिकोण के साथ कुछ अन्य उत्तर हैं - हालांकि अब मैं देख रहा हूं कि आप कैलेंडर वस्तुओं की सीधे तुलना कर रहे हैं जबकि वे बड़े पैमाने पर गेटटाइम () की तुलना करते हैं।

— Rup

-2

इसी से मेरा काम बना है:

var Date1 = new Date(dateObject1.toDateString()); //this sets time to 00:00:00
var Date2 = new Date(dateObject2.toDateString()); 
//do a normal compare
if(Date1 > Date2){ //do something }

— technomama
स्रोत

2

आपके "सामान्य" की तुलना जावा में भी नहीं होगी। यदि ऐसा होता है, तो यह ऑब्जेक्ट संदर्भों की तुलना करेगा, लेकिन इसकी अनुमति नहीं है।

— स्टिवलो

मैंने मार्कडाउन को जोड़ने के लिए संपादन किया, लेकिन स्टिवलो सही है। मुझे नहीं पता कि उस कोड ने "आपके लिए कैसे काम किया।"

— पोप

यह शायद js है।

— एंड्री लुइज़

-2

कैसे के बारे में DateUtil.daysBetween()। यह जावा है और यह एक संख्या (दिनों में अंतर) लौटाता है।

— जूल्स
स्रोत

समय भाग के बिना दो तिथियों की तुलना कैसे करें?

tl; डॉ

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

Java.time का उपयोग करना

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

जावा 8 java.timeकक्षाएं

कोई जावा 8 नहीं?

पुराने ढंग के हैं

समय क्षेत्र निर्भरता

संपर्क

जावा 8 `java.time`कक्षाएं