दिलचस्प पोस्ट
एक्सएमएल को जेएसओएन में जावा में परिवर्तित करने का सबसे तेज़ तरीका एमवीवीएम के साथ डब्ल्यूपीएफ में संवाद के लिए अच्छा या बुरा अभ्यास? क्रॉसब्रॉयर ऑनबीयरनलोड? एक HTML तालिका में कॉलम छिपाएं / दिखाएं क्या सी # के 'के लिए VB.NET बराबर है?' ऑपरेटर? आप एक्सेस के विकास के साथ संस्करण नियंत्रण का उपयोग कैसे करते हैं? क्या फ़ंक्शन के अस्तित्व की जांच करने के लिए टेम्पलेट लिखना संभव है? Node.js / विंडोज त्रुटि: ENOENT, स्टेट 'सी: \ उपयोगकर्ता \ आरटी \ एपडाटा \ रोमिंग \ npm' आप एक नियमित अभिव्यक्ति में एक चर का उपयोग कैसे करते हैं? ExecuteScalar, ExecuteReader और ExecuteNonQuery के बीच अंतर क्या है? क्या लूप का उपयोग करने के लिए ब्रेक का इस्तेमाल करना बुरा व्यवहार है? पायथन कोड फ़ंक्शन में तेजी से क्यों चलता है? शब्दकोश कुंजी के रूप में कस्टम प्रकार का उद्देश्य स्कैटर प्लॉट को कैसे सजीव करना है? आर में पढ़ने के लिए एक विशाल (3.5 जीबी) सीएसवी फ़ाइल ट्रिम कर रहा है

जावा 8: दो स्थानीय डेटटाइम के बीच अंतर की गणना करें

मैं दो LocalDateTime बीच अंतर की गणना करने का प्रयास कर रहा हूं

उत्पादन को प्रारूप स्वरूप y years m months d days h hours m minutes s seconds । यहाँ मैंने लिखा है:

 import java.time.Duration; import java.time.Instant; import java.time.LocalDateTime; import java.time.Period; import java.time.ZoneId; public class Main { static final int MINUTES_PER_HOUR = 60; static final int SECONDS_PER_MINUTE = 60; static final int SECONDS_PER_HOUR = SECONDS_PER_MINUTE * MINUTES_PER_HOUR; public static void main(String[] args) { LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 9, 19, 46, 45); LocalDateTime fromDateTime = LocalDateTime.of(1984, 12, 16, 7, 45, 55); Period period = getPeriod(fromDateTime, toDateTime); long time[] = getTime(fromDateTime, toDateTime); System.out.println(period.getYears() + " years " + period.getMonths() + " months " + period.getDays() + " days " + time[0] + " hours " + time[1] + " minutes " + time[2] + " seconds."); } private static Period getPeriod(LocalDateTime dob, LocalDateTime now) { return Period.between(dob.toLocalDate(), now.toLocalDate()); } private static long[] getTime(LocalDateTime dob, LocalDateTime now) { LocalDateTime today = LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), dob.getHour(), dob.getMinute(), dob.getSecond()); Duration duration = Duration.between(today, now); long seconds = duration.getSeconds(); long hours = seconds / SECONDS_PER_HOUR; long minutes = ((seconds % SECONDS_PER_HOUR) / SECONDS_PER_MINUTE); long secs = (seconds % SECONDS_PER_MINUTE); return new long[]{hours, minutes, secs}; } } 

मुझे जो आउटपुट मिल रहा है वह 29 years 8 months 24 days 12 hours 0 minutes 50 seconds । मैंने इस वेबसाइट से मेरे परिणाम की जांच की है (मान के साथ 12/16/1984 07:45:55 और 09/09/2014 19:46:45 )। निम्न स्क्रीनशॉट आउटपुट दिखाता है:

युग कन्वर्टर

मुझे पूरा यकीन है कि महीने के बाद के खेतों मेरे कोड से गलत हो रहा है। कोई भी सुझाव बहुत उपयोगी होगा

अद्यतन करें

मैंने अपने परिणाम को किसी अन्य वेबसाइट से परीक्षण किया है और परिणाम मुझे मिला है। यहां यह है: दो तिथियों के बीच अवधि की गणना करें (परिणाम: 29 साल, 8 महीने, 24 दिन, 12 घंटे, 0 मिनट और 50 सेकंड)।

अद्यतन करें

चूंकि मुझे दो अलग-अलग साइटों से दो अलग-अलग परिणाम मिला, मैं सोच रहा हूं कि मेरी गणना का एल्गोरिथ्म वैध है या नहीं। अगर मैं निम्नलिखित LocalDateTime ऑब्जेक्ट का उपयोग करता हूं:

 LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 10, 6, 40, 45); LocalDateTime fromDateTime = LocalDateTime.of(1984, 12, 16, 7, 45, 55); 

तब उत्पादन आ रहा है: 29 years 8 months 25 days -1 hours -5 minutes -10 seconds.

इस लिंक से यह 29 years 8 months 24 days 22 hours, 54 minutes and 50 seconds । इसलिए एल्गोरिथम को नकारात्मक संख्याओं को भी संभालना आवश्यक है।

ध्यान दें सवाल यह नहीं है कि किस साइट ने मुझे परिणाम दिया, मुझे सही एल्गोरिथम जानने की आवश्यकता है और सही परिणाम होने की आवश्यकता है

वेब के समाधान से एकत्रित समाधान "जावा 8: दो स्थानीय डेटटाइम के बीच अंतर की गणना करें"

दुर्भाग्य से ऐसा अवधि नहीं दिखती है जो समय के साथ-साथ फैल जाती है, इसलिए आपको स्वयं की गणना करना पड़ सकता है

बेबात से दिनांक और समय कक्षाओं में बहुत उपयोगिता पद्धतियां होती हैं जो कि कुछ हद तक आसान होती हैं। यहां तक ​​कि अंतर की गणना करने का एक तरीका है, हालांकि जरूरी नहीं कि सबसे तेज:

 LocalDateTime fromDateTime = LocalDateTime.of(1984, 12, 16, 7, 45, 55); LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 10, 6, 40, 45); LocalDateTime tempDateTime = LocalDateTime.from( fromDateTime ); long years = tempDateTime.until( toDateTime, ChronoUnit.YEARS); tempDateTime = tempDateTime.plusYears( years ); long months = tempDateTime.until( toDateTime, ChronoUnit.MONTHS); tempDateTime = tempDateTime.plusMonths( months ); long days = tempDateTime.until( toDateTime, ChronoUnit.DAYS); tempDateTime = tempDateTime.plusDays( days ); long hours = tempDateTime.until( toDateTime, ChronoUnit.HOURS); tempDateTime = tempDateTime.plusHours( hours ); long minutes = tempDateTime.until( toDateTime, ChronoUnit.MINUTES); tempDateTime = tempDateTime.plusMinutes( minutes ); long seconds = tempDateTime.until( toDateTime, ChronoUnit.SECONDS); System.out.println( years + " years " + months + " months " + days + " days " + hours + " hours " + minutes + " minutes " + seconds + " seconds."); //prints: 29 years 8 months 24 days 22 hours 54 minutes 50 seconds. 

बुनियादी विचार यह है: एक अस्थायी शुरुआत की तारीख बनाएं और पूरे साल पूरा होने दें फिर उस तारीख को वर्ष की संख्या से समायोजित करें ताकि शुरुआत की तारीख एक वर्ष अंत तक कम हो। दो बार दोहराएं कि प्रत्येक समय इकाई में अवरोही क्रम में

अंत में एक अस्वीकरण: मैंने अलग-अलग समयक्षेत्रों को ध्यान में नहीं लिया (दोनों तिथियां एक ही समयक्षेत्र में होनी चाहिए) और मैंने भी परीक्षण / जांच नहीं की कि कैसे दिन के उजाले की बचत का समय या कैलेंडर में अन्य बदलाव (समोआ में समय क्षेत्र परिवर्तन) इस गणना को प्रभावित करें तो देखभाल के साथ उपयोग करें

मुझे यह करने का सबसे अच्छा तरीका है ChronoUnit के साथ मिला

 long minutes = ChronoUnit.MINUTES.between(fromDate, toDate); long hours = ChronoUnit.HOURS.between(fromDate, toDate); 

अतिरिक्त दस्तावेज यहां है: https://docs.oracle.com/javase/tutorial/datetime/iso/period.html

'Hh: mm: ss' प्रारूप में आने के लिए अवधि और समय यूनिट का उपयोग करते हुए यहां एक उदाहरण।

  Duration dur = Duration.between(LocalDateTimeIni, LocalDateTimeEnd); long millis = dur.toMillis(); String.format("%02d:%02d:%02d", TimeUnit.MILLISECONDS.toHours(millis), TimeUnit.MILLISECONDS.toMinutes(millis) - TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)), TimeUnit.MILLISECONDS.toSeconds(millis) - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis))); 

और Groovy के साथ @ थॉमस का संस्करण वांछित इकाइयों को मूल्यों को हार्डकोडिंग के बजाय एक सूची में लेता है यह कार्यान्वयन (जो आसानी से जावा में लगाया जा सकता है – मैंने फ़ंक्शन घोषणा स्पष्ट की है) थॉमस दृष्टिकोण को अधिक पुन: उपयोग करने योग्य बनाता है

 def fromDateTime = LocalDateTime.of(1968, 6, 14, 0, 13, 0) def toDateTime = LocalDateTime.now() def listOfUnits = [ ChronoUnit.YEARS, ChronoUnit.MONTHS, ChronoUnit.DAYS, ChronoUnit.HOURS, ChronoUnit.MINUTES, ChronoUnit.SECONDS, ChronoUnit.MILLIS] println calcDurationInTextualForm(listOfUnits, fromDateTime, toDateTime) String calcDurationInTextualForm(List<ChronoUnit> listOfUnits, LocalDateTime ts, LocalDateTime to) { def result = [] listOfUnits.each { chronoUnit -> long amount = ts.until(to, chronoUnit) ts = ts.plus(amount, chronoUnit) if (amount) { result << "$amount ${chronoUnit.toString()}" } } result.join(', ') } 

इस लेखन के समय, ऊपर दिए गए कोड में 47 Years, 8 Months, 9 Days, 22 Hours, 52 Minutes, 7 Seconds, 140 Millis रिटर्न मिलता है। और, @ गेन्नेडी कोलोमेट्स इनपुट के लिए, कोड रिटर्न 23 Hours

जब आप इकाइयों की एक सूची प्रदान करते हैं, तो यह इकाइयों के आकार (सबसे पहले सबसे पहले) के आधार पर क्रमबद्ध होना चाहिए:

 def listOfUnits = [ChronoUnit.WEEKS, ChronoUnit.DAYS, ChronoUnit.HOURS] // returns 2495 Weeks, 3 Days, 8 Hours 

तपस बोस कोड और थॉमस कोड के लिए कुछ समस्या है। यदि समय differense ऋणात्मक है, तो सरणी को नकारात्मक मान मिलेंगे। उदाहरण के लिए यदि

 LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 10, 6, 46, 45); LocalDateTime fromDateTime = LocalDateTime.of(2014, 9, 9, 7, 46, 45); 

यह 0 वर्ष 0 महीने 1 दिन -1 घंटे 0 मिनट 0 सेकंड देता है।

मुझे लगता है कि सही आउटपुट है: 0 साल 0 महीने 0 दिन 23 घंटे 0 मिनट 0 सेकंड।

मैं LocalDateTime उदाहरणों को LocalDate और LocalTime उदाहरणों को अलग करने का प्रस्ताव करता हूं उसके बाद हम जावा 8 अवधि और अवधि के उदाहरण प्राप्त कर सकते हैं। अवधि का उदाहरण दिन की संख्या और पूरे दिन के समय मूल्य (<24 घंटों) से अवधि मूल्य के बाद के सुधार के साथ अलग है। जब दूसरा लोकल टाइम वैल्यू पहले लोकल टाइम वैल्यू के पहले होता है, तो यह एक दिन की अवधि कम करने के लिए आवश्यक है।

LocalDateTime अंतर की गणना करने के लिए यहां मेरा तरीका है:

 private void getChronoUnitForSecondAfterFirst(LocalDateTime firstLocalDateTime, LocalDateTime secondLocalDateTime, long[] chronoUnits) { /*Separate LocaldateTime on LocalDate and LocalTime*/ LocalDate firstLocalDate = firstLocalDateTime.toLocalDate(); LocalTime firstLocalTime = firstLocalDateTime.toLocalTime(); LocalDate secondLocalDate = secondLocalDateTime.toLocalDate(); LocalTime secondLocalTime = secondLocalDateTime.toLocalTime(); /*Calculate the time difference*/ Duration duration = Duration.between(firstLocalDateTime, secondLocalDateTime); long durationDays = duration.toDays(); Duration throughoutTheDayDuration = duration.minusDays(durationDays); Logger.getLogger(PeriodDuration.class.getName()).log(Level.INFO, "Duration is: " + duration + " this is " + durationDays + " days and " + throughoutTheDayDuration + " time."); Period period = Period.between(firstLocalDate, secondLocalDate); /*Correct the date difference*/ if (secondLocalTime.isBefore(firstLocalTime)) { period = period.minusDays(1); Logger.getLogger(PeriodDuration.class.getName()).log(Level.INFO, "minus 1 day"); } Logger.getLogger(PeriodDuration.class.getName()).log(Level.INFO, "Period between " + firstLocalDateTime + " and " + secondLocalDateTime + " is: " + period + " and duration is: " + throughoutTheDayDuration + "\n-----------------------------------------------------------------"); /*Calculate chrono unit values and write it in array*/ chronoUnits[0] = period.getYears(); chronoUnits[1] = period.getMonths(); chronoUnits[2] = period.getDays(); chronoUnits[3] = throughoutTheDayDuration.toHours(); chronoUnits[4] = throughoutTheDayDuration.toMinutes() % 60; chronoUnits[5] = throughoutTheDayDuration.getSeconds() % 60; } 

उपरोक्त विधि का उपयोग किसी भी स्थानीय तिथि और समय मानों के अंतर की गणना के लिए किया जा सकता है, उदाहरण के लिए:

 public long[] getChronoUnits(String firstLocalDateTimeString, String secondLocalDateTimeString) { DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); LocalDateTime firstLocalDateTime = LocalDateTime.parse(firstLocalDateTimeString, formatter); LocalDateTime secondLocalDateTime = LocalDateTime.parse(secondLocalDateTimeString, formatter); long[] chronoUnits = new long[6]; if (secondLocalDateTime.isAfter(firstLocalDateTime)) { getChronoUnitForSecondAfterFirst(firstLocalDateTime, secondLocalDateTime, chronoUnits); } else { getChronoUnitForSecondAfterFirst(secondLocalDateTime, firstLocalDateTime, chronoUnits); } return chronoUnits; } 

उपरोक्त विधि के लिए एक इकाई परीक्षण लिखने के लिए सुविधाजनक है (इनमें से दोनों अवधि अवधि वर्ग सदस्य हैं)। यहां कोड है:

 @RunWith(Parameterized.class) public class PeriodDurationTest { private final String firstLocalDateTimeString; private final String secondLocalDateTimeString; private final long[] chronoUnits; public PeriodDurationTest(String firstLocalDateTimeString, String secondLocalDateTimeString, long[] chronoUnits) { this.firstLocalDateTimeString = firstLocalDateTimeString; this.secondLocalDateTimeString = secondLocalDateTimeString; this.chronoUnits = chronoUnits; } @Parameters public static Collection<Object[]> periodValues() { long[] chronoUnits0 = {0, 0, 0, 0, 0, 0}; long[] chronoUnits1 = {0, 0, 0, 1, 0, 0}; long[] chronoUnits2 = {0, 0, 0, 23, 0, 0}; long[] chronoUnits3 = {0, 0, 0, 1, 0, 0}; long[] chronoUnits4 = {0, 0, 0, 23, 0, 0}; long[] chronoUnits5 = {0, 0, 1, 23, 0, 0}; long[] chronoUnits6 = {29, 8, 24, 12, 0, 50}; long[] chronoUnits7 = {29, 8, 24, 12, 0, 50}; return Arrays.asList(new Object[][]{ {"2015-09-09 21:46:44", "2015-09-09 21:46:44", chronoUnits0}, {"2015-09-09 21:46:44", "2015-09-09 22:46:44", chronoUnits1}, {"2015-09-09 21:46:44", "2015-09-10 20:46:44", chronoUnits2}, {"2015-09-09 21:46:44", "2015-09-09 20:46:44", chronoUnits3}, {"2015-09-10 20:46:44", "2015-09-09 21:46:44", chronoUnits4}, {"2015-09-11 20:46:44", "2015-09-09 21:46:44", chronoUnits5}, {"1984-12-16 07:45:55", "2014-09-09 19:46:45", chronoUnits6}, {"2014-09-09 19:46:45", "1984-12-16 07:45:55", chronoUnits6} }); } @Test public void testGetChronoUnits() { PeriodDuration instance = new PeriodDuration(); long[] expResult = this.chronoUnits; long[] result = instance.getChronoUnits(this.firstLocalDateTimeString, this.secondLocalDateTimeString); assertArrayEquals(expResult, result); } 

}

सभी परीक्षण सफल हैं या नहीं, पहले स्थानीय डेटटाइम का मान पहले और किसी लोकलटाइम मूल्यों के लिए है।

यहां आपके प्रश्न का एक बहुत सरल जवाब है। यह काम करता हैं।

 import java.time.*; import java.util.*; import java.time.format.DateTimeFormatter; public class MyClass { public static void main(String args[]) { DateTimeFormatter T = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm"); Scanner h = new Scanner(System.in); System.out.print("Enter date of birth[dd/mm/yyyy hh:mm]: "); String b = h.nextLine(); LocalDateTime bd = LocalDateTime.parse(b,T); LocalDateTime cd = LocalDateTime.now(); int hr = cd.getHour() - bd.getHour(); int mn = cd.getMinute() - bd.getMinute(); Period time = Period.between(bd.toLocalDate(),cd.toLocalDate()); System.out.print("Age is: "+time.getYears()+ " years,"+time.getMonths()+ " months, " +time.getDays()+ " days, "+hr+ " hours, " +mn+ " minutes old"); } }