जावा 8 में दो तिथियों के बीच के दिनों की गणना करें

Question

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

इन प्रतिबंधों के साथ शिकायत करने की आवश्यकता है:

1. दिनांक बचत से त्रुटियों को रोकें
2. इनपुट दो दिनांक की वस्तुएं हैं (समय के बिना, मैं स्थानीय समय-काल जानता हूं, लेकिन मुझे दिनांक उदाहरणों के साथ करने की आवश्यकता है)

Comments

उदाहरण के लिए कुछ इस तरह ?

— मध्‍यग्रामग्राम

@MadProgrammer वास्तव में नहीं - अवधि ऐसा करने के लिए सबसे उपयुक्त नहीं है ...

— assylias

@assylias खैर, यह ओपी के पास जो था उससे बेहतर है

— MadProgrammer

@assylias फिर क्या है?

— मद्रग्राम

@MadProgrammer DAYS.between(localDate1, localDate2)।

— 9

Answer 1

यदि आप तार्किक कैलेंडर दिन चाहते हैं , तो निम्न DAYS.between()विधि का उपयोग करें java.time.temporal.ChronoUnit:

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

यदि आप 24 घंटे (एक अवधि ) शाब्दिक चाहते हैं , तो आप Durationइसके बजाय कक्षा का उपयोग कर सकते हैं :

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

अधिक जानकारी के लिए, इस दस्तावेज़ को देखें ।

Comments

यह एक अपवाद फेंकता है, क्योंकि Duration.between विधि को अस्थायी वस्तुओं की आवश्यकता होती है जो SECONDS इकाई का समर्थन करने में सक्षम हो । इसके बजाय, प्रयास करें Duration.between(today.atTime(0, 0), yesterday.atTime(0, 0)).toDays()।

— वीजीआर

इसके बजाय today.atTime(0, 0)आप कर सकते हैं today.atStartOfDay()।

— eee

@REACHUS शायद -1 थोड़ा कठोर था क्योंकि आप जिस कोड को प्रस्तावित करते हैं, लेकिन अवधि "समय-आधारित मात्रा" को मापने के लिए होती है। कई दिनों तक मापने का एक अंतर्निहित तरीका है, जिसे तिथि से डेटटाइम में परिवर्तित करने की आवश्यकता नहीं होती है।

— अस्वच्छता

LocalDate का बेहतर उत्तर है @Sunil B का उत्तर नीचे दिया गया है:ChronoUnit.DAYS.between(firstDate, secondDate)

— लैपरो

@ लैपरो यह बेहतर क्यों है? यह मेरे उत्तर के रूप में एक ही विधि का उपयोग करता है

— वाक्य रचना

Answer 2

वीजीआर की टिप्पणियों के आधार पर यहां वह है जो आप उपयोग कर सकते हैं:

ChronoUnit.DAYS.between(firstDate, secondDate)

Answer 3

आप उपयोग कर सकते हैं 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));

Comments

गेटा मैं अभी पहले संस्करण के साथ सामना किया untilहै कि यह एक पीरियड ऑब्जेक्ट देता है । यह दो वर्षों के बीच कई वर्षों / महीनों / दिनों को लौटाएगा, वास्तविक दिनों की संख्या नहीं। और अवधि पर getDays () केवल दिनों की कुल संख्या के बजाय दिनों के हिस्से (वर्षों या महीनों की संख्या को ध्यान में रखते हुए) को वापस करता है। दूसरा संस्करण ठीक उसी तरह से काम करता है जैसे दो तिथियों के बीच कई दिनों के लिए।

— एम। जस्टिन

क्या इसके लिए कोई पूर्ण विकल्प है? चूंकि इसे एंड्रॉइड

— एसडीके

Answer 4

DAYS.betweenसे उपयोग कर सकते हैंjava.time.temporal.ChronoUnit

जैसे

import java.time.temporal.ChronoUnit;

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

Answer 5

यदि स्टार्टडेट और एंडडेट java.util.Date के उदाहरण हैं

हम ChronoUnit enum के बीच () विधि का उपयोग कर सकते हैं :

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

ChronoUnit.DAYS दिनों की गिनती जो 24 घंटे पूरा करती है ।

import java.time.temporal.ChronoUnit;

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

//OR 

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

Answer 6

Enum java.time.temporal.ChronoUnit में DAYS का उपयोग करें । नीचे नमूना कोड है:

आउटपुट: * प्रारंभ तिथि: 2015-03-01 और अंतिम तिथि: 2016-03-03 के बीच दिनों की संख्या ==> 368 है। ** प्रारंभ तिथि के बीच दिनों की संख्या: 2016-03-03 और अंतिम तिथि: 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);

    }

}

Answer 7

सभी लोग ChronoUnit.DAYS.between का उपयोग करने के लिए कह रहे हैं, लेकिन यह सिर्फ एक और विधि को दर्शाता है जिसे आप स्वयं कह सकते हैं। तो आप भी कर सकते थे firstDate.until(secondDate, ChronoUnit.DAYS)।

दोनों के लिए डॉक्स वास्तव में दोनों दृष्टिकोणों का उल्लेख करते हैं और कहते हैं कि जो भी अधिक पढ़ने योग्य हो, उसका उपयोग करें।

Comments

FWIW ... मुझे यकीन नहीं है कि दोनों क्यों मौजूद हैं। क्या ऐसा समय है कि एक अधिक पठनीय है और दूसरा समय वह है? कब क्यों?

— नाफग

Answer 8

हेयर यू गो:

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

Answer 9

वर्तमान दिन से क्रिसमस से पहले दिनों की संख्या प्राप्त करें, यह प्रयास करें

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

Answer 10

यदि लक्ष्य को केवल दिनों में अंतर प्राप्त करना है और चूंकि उपरोक्त उत्तर प्रतिनिधि विधियों के बारे में उल्लेख करते हैं, तो यह इंगित करना चाहेंगे कि एक बार केवल एक बार भी -

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

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

Comments

'पीरियड.बेटी (तारीख 1, तारीख 2) .गोतेड्स ()' का उपयोग किए बिना जाल में गिरने पर यह महसूस किए बिना कि आप अंतर के महीनों और वर्षों को ढीला करते हैं।

— MrSmith42

Answer 11

दो तारीखों के बीच का दिन java.util.Date का उदाहरण है

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

Answer 12

मुझे पता है कि यह सवाल जावा 8 के लिए है, लेकिन जावा 9 के साथ आप उपयोग कर सकते हैं:

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

Answer 13

अपनी आवश्यकताओं को पूरा करने वाले वर्ग या विधि का उपयोग करें:

• अवधि वर्ग,
• अवधि वर्ग,
• या ChronoUnit.between विधि।

एक अवधि समय-आधारित मान (सेकंड, नैनोसेकंड) का उपयोग करके समय की मात्रा को मापता है।

एक अवधि दिनांक-आधारित मानों (वर्षों, महीनों, दिनों) का उपयोग करती है।

ChronoUnit.between विधि उपयोगी है जब आप समय की एक इकाई में केवल समय की मात्रा को मापना चाहते हैं, जैसे कि दिन या सेकंड।

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