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

Question

मैं एक जावा प्रोग्राम चाहता हूं जो दो तिथियों के बीच दिनों की गणना करता है।

1. पहली तारीख टाइप करें (जर्मन संकेतन; व्हॉट्सएप के साथ: "dd mm yyyy"):
2. दूसरी तारीख टाइप करें।
3. कार्यक्रम को दो तिथियों के बीच दिनों की संख्या की गणना करनी चाहिए।

मैं लीप वर्ष और ग्रीष्मकाल कैसे शामिल कर सकता हूं?

मेरा कोड:

import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;

public class NewDateDifference {

    public static void main(String[] args) {

        System.out.print("Insert first date: ");
        Scanner s = new Scanner(System.in);
        String[] eingabe1 = new String[3];

        while (s.hasNext()) {
            int i = 0;
            insert1[i] = s.next();
            if (!s.hasNext()) {
                s.close();
                break;
            }
            i++;
        }

        System.out.print("Insert second date: ");
        Scanner t = new Scanner(System.in);
        String[] insert2 = new String[3];

        while (t.hasNext()) {
            int i = 0;
            insert2[i] = t.next();
            if (!t.hasNext()) {
                t.close();
                break;
            }
            i++;
        }

        Calendar cal = Calendar.getInstance();

        cal.set(Calendar.DAY_OF_MONTH, Integer.parseInt(insert1[0]));
        cal.set(Calendar.MONTH, Integer.parseInt(insert1[1]));
        cal.set(Calendar.YEAR, Integer.parseInt(insert1[2]));
        Date firstDate = cal.getTime();

        cal.set(Calendar.DAY_OF_MONTH, Integer.parseInt(insert2[0]));
        cal.set(Calendar.MONTH, Integer.parseInt(insert2[1]));
        cal.set(Calendar.YEAR, Integer.parseInt(insert2[2]));
        Date secondDate = cal.getTime();


        long diff = secondDate.getTime() - firstDate.getTime();

        System.out.println ("Days: " + diff / 1000 / 60 / 60 / 24);
    }
}

Comments

क्या काम नहीं करता है? क्या यह दुर्घटनाग्रस्त है? क्या यह आपको गलत नंबर दे रहा है?

— jens108

सरणी की घोषणा कहां है: इन्सर्ट 1?

— Rhys

Insert1 = जर्मन में eingabe1 :)

— peter.petrov

@ peter.petrov आह, मैं देख रहा हूँ!

— रियास

मुझे लगता है कि वह के साथ इस मुद्दे चल रहा है mmऔर MM: पी

— ऋषि

Answer 1

अद्यतन: 2013 से मूल उत्तर अब पुराना हो गया है क्योंकि कुछ वर्गों को बदल दिया गया है। ऐसा करने का नया तरीका नई java.timeकक्षाओं का उपयोग कर रहा है ।

DateTimeFormatter dtf = DateTimeFormatter.ofPattern("dd MM yyyy");
String inputString1 = "23 01 1997";
String inputString2 = "27 04 1997";

try {
    LocalDateTime date1 = LocalDate.parse(inputString1, dtf);
    LocalDateTime date2 = LocalDate.parse(inputString2, dtf);
    long daysBetween = Duration.between(date1, date2).toDays();
    System.out.println ("Days: " + daysBetween);
} catch (ParseException e) {
    e.printStackTrace();
}

ध्यान दें कि यह समाधान वास्तविक 24 घंटे-दिनों की संख्या देगा, कैलेंडर दिनों की संख्या नहीं। बाद के लिए, का उपयोग करें

long daysBetween = ChronoUnit.DAYS.between(date1, date2)

---

मूल उत्तर (जावा 8 के रूप में पुराना)

आप अपने स्ट्रिंग्स के साथ कुछ रूपांतरण कर रहे हैं जो आवश्यक नहीं हैं। SimpleDateFormatइसके लिए एक वर्ग है - यह प्रयास करें:

SimpleDateFormat myFormat = new SimpleDateFormat("dd MM yyyy");
String inputString1 = "23 01 1997";
String inputString2 = "27 04 1997";

try {
    Date date1 = myFormat.parse(inputString1);
    Date date2 = myFormat.parse(inputString2);
    long diff = date2.getTime() - date1.getTime();
    System.out.println ("Days: " + TimeUnit.DAYS.convert(diff, TimeUnit.MILLISECONDS));
} catch (ParseException e) {
    e.printStackTrace();
}

संपादित करें: चूंकि इस कोड की शुद्धता के बारे में कुछ चर्चाएं हुई हैं: यह वास्तव में लीप वर्षों का ध्यान रखता है। हालाँकि, TimeUnit.DAYS.convertफ़ंक्शन परिशुद्धता खो देता है क्योंकि मिलीसेकंड दिनों में परिवर्तित हो जाते हैं (अधिक जानकारी के लिए लिंक किए गए दस्तावेज़ देखें)। यदि यह एक समस्या है, तो diffइसे हाथ से भी परिवर्तित किया जा सकता है:

float days = (diff / (1000*60*60*24));

ध्यान दें कि यह एक floatमूल्य है, जरूरी नहीं कि ए int।

Comments

यह एक खराब कार्यान्वयन है जो लीप वर्षों को ठीक से नहीं खाता है।

— ग्रूवी एड

TimeUnit.DAYS.convert (अंतर, TimeUnit.MILLISECONDS)); <३

— गुहिगो

@GroovyEd मैंने जो परीक्षण किया है उससे ऐसा लगता है कि इस कोड को लीप वर्षों के साथ कोई समस्या नहीं है। कृपया ध्यान दें कि TimeUnit.Days.convert () शेष इकाइयों को अनदेखा कर देगा जैसे कि 999 मिली सेकेंड को सेकंड में परिणाम में परिवर्तित करना। 0. इसका मतलब है कि यदि आप नई तिथि () को उन दिनांक ऑब्जेक्ट्स में से एक के रूप में उपयोग करते हैं जो आपको एक दिन से कम मिल सकती हैं, तो आप इसकी देखभाल करें

— क्लिटोस जी।

यह लीप वर्ष के लिए भी काम करता है। इस String inputString1 = "28 2 2016"; String inputString2 = "1 3 2016";ans की जाँच करें : 2

— रोहित गायकवाड़

मेरा मानना ​​है कि यह लीप वर्षों के लिए सही ढंग से काम करता है, लेकिन यह दिन के उजाले की बचत के समय को गड़बड़ कर देता है। यदि आपके स्थान पर दिन की बचत का समय है, तो हर साल, एक दिन 23 घंटे का होता है और एक दिन 25 घंटे का होता है। यह समाधान गलत तरीके से मानता है कि हर दिन 24 घंटे है। इसलिए यह किसी भी अवधि के लिए गलत उत्तर देता है जो गैर-दिन की बचत के दौरान शुरू होता है और दिन के उजाले की बचत के दौरान समाप्त होता है। इस समाधान का उपयोग न करें - बेहतर तरीके हैं।

— दाऊद इब्न करीम

Answer 2

सबसे सरल तरीका:

public static long getDifferenceDays(Date d1, Date d2) {
    long diff = d2.getTime() - d1.getTime();
    return TimeUnit.DAYS.convert(diff, TimeUnit.MILLISECONDS);
}

Comments

खैर, मूल रूप से यह वर्तमान सर्वोत्तम उत्तर के समान है , हालांकि यह उत्तर इसे एक फ़ंक्शन के रूप में प्रदान करता है।

— एंड्रयू टी।

ध्यान दें, यह केवल तभी गिना जाता है जब दो तिथियों के बीच का समय अंतराल 24 घंटे (कोड से बहुत स्पष्ट) से बड़ा हो, इस प्रकारgetDifferenceDays(11PM, 4 AM nextday) == 0

— पुनरावृत्ति

यह कार्यान्वयन आज की तरह अंतिम दिन है। उदाहरण के लिए, यदि मैं d1 = आज, और d2 = कल के साथ कार्यक्रम चलाता हूं, तो 0 दिन

— मिलते हैं

@ क्योंकि जून में 30 दिन हैं।

— दाऊद इब्न करीम

यह उत्तर गलत है। यह दिन के उजाले बचत समय के साथ सही तरीके से नहीं निपटता है। यदि आप सही परिणाम चाहते हैं तो इसका उपयोग न करें।

— दाऊद इब्न करीम

Answer 3

Java 8 में, आप इसका उपयोग करके LocalDateऔर इसे पूरा कर सकते हैं DateTimeFormatter। के जावदोक से LocalDate:

लोकलडेट एक अपरिवर्तनीय तारीख-समय ऑब्जेक्ट है जो एक तिथि का प्रतिनिधित्व करता है, जिसे अक्सर वर्ष-महीने-दिन के रूप में देखा जाता है।

और पैटर्न का उपयोग करके निर्माण किया जा सकता है DateTimeFormatter। यहाँ Javadoc , और प्रासंगिक पैटर्न वर्ण हैं जिनका मैंने उपयोग किया है:

प्रतीक - अर्थ - प्रस्तुति - उदाहरण

y - वर्ष-के-युग - वर्ष - 2004; 04

एम / एल - महीने का वर्ष - संख्या / पाठ - 7; 07; जुलाई; जुलाई; जे

डी - दिन के महीने - संख्या - 10

यहाँ उदाहरण है:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;

public class Java8DateExample {
    public static void main(String[] args) throws IOException {
        final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd MM yyyy");
        final BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        final String firstInput = reader.readLine();
        final String secondInput = reader.readLine();
        final LocalDate firstDate = LocalDate.parse(firstInput, formatter);
        final LocalDate secondDate = LocalDate.parse(secondInput, formatter);
        final long days = ChronoUnit.DAYS.between(firstDate, secondDate);
        System.out.println("Days between: " + days);
    }
}

उदाहरण इनपुट / आउटपुट हाल ही में अंतिम के साथ:

23 01 1997
27 04 1997
Days between: 94

पहले हाल के साथ:

27 04 1997
23 01 1997
Days between: -94

ठीक है, आप इसे सरल तरीके से कर सकते हैं:

public static long betweenDates(Date firstDate, Date secondDate) throws IOException
{
    return ChronoUnit.DAYS.between(firstDate.toInstant(), secondDate.toInstant());
}

Comments

बहुत बढ़िया उदाहरण है। यह स्वचालित रूप से लीप वर्ष के लिए खाता है। यदि आपने 1991 और 1992 (लीप वर्ष) की जाँच की तो यह सही गणना करता है। उत्तम!

— वोहागुई

मानक पुस्तकालय का महान उपयोग।

— dieresys

यह वर्तमान स्वीकृत उत्तर होना चाहिए। मानक पुस्तकालय का उपयोग और लीप वर्ष और दिन के उजाले की बचत के लिए एक समस्या नहीं होगी।

— पेहोमोलू

यह वर्तमान / आधुनिक उत्तर है (अन्य पुराने हैं)। यह गर्मियों के समय (डीएसटी) के लिए भी जिम्मेदार है। जावा 6 या 7 का उपयोग करने के लिए, थ्रीटेन बैकपोर्ट प्राप्त करें । नए-नए एंड्रॉइड थ्रीटेनबप पर नहीं ।

— ओले वीवी

यह दिन के उजाले की बचत के समय को ध्यान में नहीं रखता है

— एलेक्स

Answer 4

अधिकांश / सभी उत्तरों ने हमारे लिए मुद्दों को जन्म दिया जब दिन के उजाले की बचत का समय लगभग आ गया। JodaTime का उपयोग किए बिना, सभी तिथियों के लिए यहां हमारा कार्य समाधान है। यह कैलेंडर वस्तुओं का उपयोग करता है:

public static int daysBetween(Calendar day1, Calendar day2){
    Calendar dayOne = (Calendar) day1.clone(),
            dayTwo = (Calendar) day2.clone();

    if (dayOne.get(Calendar.YEAR) == dayTwo.get(Calendar.YEAR)) {
        return Math.abs(dayOne.get(Calendar.DAY_OF_YEAR) - dayTwo.get(Calendar.DAY_OF_YEAR));
    } else {
        if (dayTwo.get(Calendar.YEAR) > dayOne.get(Calendar.YEAR)) {
            //swap them
            Calendar temp = dayOne;
            dayOne = dayTwo;
            dayTwo = temp;
        }
        int extraDays = 0;

        int dayOneOriginalYearDays = dayOne.get(Calendar.DAY_OF_YEAR);

        while (dayOne.get(Calendar.YEAR) > dayTwo.get(Calendar.YEAR)) {
            dayOne.add(Calendar.YEAR, -1);
            // getActualMaximum() important for leap years
            extraDays += dayOne.getActualMaximum(Calendar.DAY_OF_YEAR);
        }

        return extraDays - dayTwo.get(Calendar.DAY_OF_YEAR) + dayOneOriginalYearDays ;
    }
}

Comments

दिन के उजाले की बचत के समय को अच्छी तरह से नियंत्रित करता है

— रवि सांवल

उत्तर के लिए +1, हालांकि, जोड़ना चाहते हैं कि हमें Calendar dayOne = (Calendar) day1.clone(), dayTwo = (Calendar) day2.clone();लाइनों की आवश्यकता है क्योंकि वे सुनिश्चित करते हैं कि मूल कैलेंडर मान ओवरराइड नहीं हैं। मैंने इन पंक्तियों को निरर्थक समझते हुए हटा दिया और इस तथ्य पर एक घंटा बर्बाद कर दिया कि मेरी मूल वस्तु के मूल्य इस कार्य के अंदर से ओवरराइट हो रहे थे।

— रोहन कंडवाल

यह मत भूलो कि महीना मान कैलेंडर कक्षा में 0-आधारित है। Calendar.set (2015, 11, 30, 0, 00, 00); वास्तव में 30/12/2015 का मतलब है

— दिमित्री

Answer 5

सबसे अच्छा तरीका है, और यह एक स्ट्रिंग को बोनस के रूप में परिवर्तित करता है;)

protected void onCreate(Bundle savedInstanceState) {

    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    try {
        //Dates to compare
        String CurrentDate=  "09/24/2015";
        String FinalDate=  "09/26/2015";

        Date date1;
        Date date2;

        SimpleDateFormat dates = new SimpleDateFormat("MM/dd/yyyy");

        //Setting dates
        date1 = dates.parse(CurrentDate);
        date2 = dates.parse(FinalDate);

        //Comparing dates
        long difference = Math.abs(date1.getTime() - date2.getTime());
        long differenceDates = difference / (24 * 60 * 60 * 1000);

        //Convert long to String
        String dayDifference = Long.toString(differenceDates);

        Log.e("HERE","HERE: " + dayDifference);
    }
    catch (Exception exception) {
        Log.e("DIDN'T WORK", "exception " + exception);
    }
}

Comments

अपवाद फेंकने की क्या संभावना है?

— CoDe

ध्यान दें कि यह लीप वर्षों में काम नहीं करता है। उदाहरण के लिए, "02/15/2020" से "04/02/2020" तक 47 दिन है। यह तर्क 46 के साथ आएगा।

— user1070304

Answer 6

उपयोग:

public int getDifferenceDays(Date d1, Date d2) {
    int daysdiff = 0;
    long diff = d2.getTime() - d1.getTime();
    long diffDays = diff / (24 * 60 * 60 * 1000) + 1;
    daysdiff = (int) diffDays;
    return daysdiff;
}

Comments

क्या यह लीप वर्ष और दिन के उजाले की बचत के लिए है?

— मैक्स अलेक्जेंडर हैना

@MaxAlexanderHanna यह सही ढंग से छलांग साल के लिए खातों, लेकिन दिन के उजाले की बचत नहीं। यह केवल सही उत्तर देता है जब भी गैर-डेलाइट बचत समय के दौरान कोई अवधि शुरू होती है लेकिन दिन के उजाले की बचत के दौरान समाप्त होती है। अन्य सभी मामलों में, यह एक के बाद एक बंद है।

— दाऊद इब्न करीम

@ सईद__लिलारू "+ 1" क्या है? मुझे लगता है कि आपको इसे हटा देना चाहिए।

— अलीसा

मुझे एक समस्या थी कि INT की कास्टिंग 4 में हुई और फ्लोट करने के लिए कास्टिंग 4.9 के परिणामस्वरूप हुई, इसलिए वास्तव में मैं जो चाहता था, वह नहीं था; शायद स्पष्ट रूप से पर्याप्त नहीं है दिनांक 23:59 पर तारीख 1 और 00:01 पर तारीख 2 के लिए वर्णित मामलों और अपेक्षित परिणाम क्या होगा।

— एरिकजी

Answer 7

जावा तिथि के पुस्तकालय कुख्यात रूप से टूटे हुए हैं। मैं जोडा टाइम का उपयोग करने की सलाह दूंगा । यह आपके लिए लीप ईयर, टाइम ज़ोन आदि का ध्यान रखेगा।

न्यूनतम कार्य उदाहरण:

import java.util.Scanner;
import org.joda.time.DateTime;
import org.joda.time.Days;
import org.joda.time.LocalDate;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;

public class DateTestCase {

    public static void main(String[] args) {

        System.out.print("Insert first date: ");
        Scanner s = new Scanner(System.in);
        String firstdate = s.nextLine();
        System.out.print("Insert second date: ");
        String seconddate = s.nextLine();

        // Formatter
        DateTimeFormatter dateStringFormat = DateTimeFormat
                .forPattern("dd MM yyyy");
        DateTime firstTime = dateStringFormat.parseDateTime(firstdate);
        DateTime secondTime = dateStringFormat.parseDateTime(seconddate);
        int days = Days.daysBetween(new LocalDate(firstTime),
                                    new LocalDate(secondTime)).getDays();
        System.out.println("Days between the two dates " + days);
    }
}

Comments

इस उत्तर को कुछ तरीकों से सुधारा जा सकता था। (ए) जेवीएम के डिफ़ॉल्ट पर भरोसा करने के बजाय समय क्षेत्र निर्दिष्ट करें। तो उस DateTimeFormatter को बनाते समय, इसमें एक कॉल जोड़ें withZone( DateTimeZone.forID( "Europe/Berlin" ) )। (ख) कॉल LocalDateमें उपयोग क्यों daysBetween? बस DateTime ऑब्जेक्ट्स (फ़र्स्टटाइम, सेकंड टाइम) पास करें। पूरे दिन के लिए, फोन करें withTimeAtStartOfDays। (ग) मैं चर नाम का प्रयोग करेंगे firstDateTimeबल्कि तो firstTimeदिनांक, समय, और तारीख समय वस्तुओं के बीच अस्पष्टता से बचने के। (d) खराब डेटा इनपुट को संभालने के लिए कुछ ट्राइ-कैच जोड़ें जो हमारे अपेक्षित प्रारूप से मेल नहीं खाते।

— बेसिल बोर्के

Answer 8

String dateStart = "01/14/2015 08:29:58";
String dateStop = "01/15/2015 11:31:48";

//HH converts hour in 24 hours format (0-23), day calculation
SimpleDateFormat format = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss");

Date d1 = null;
Date d2 = null;

d1 = format.parse(dateStart);
d2 = format.parse(dateStop);

//in milliseconds
long diff = d2.getTime() - d1.getTime();

long diffSeconds = diff / 1000 % 60;
long diffMinutes = diff / (60 * 1000) % 60;
long diffHours = diff / (60 * 60 * 1000) % 24;
long diffDays = diff / (24 * 60 * 60 * 1000);

System.out.print(diffDays + " days, ");
System.out.print(diffHours + " hours, ");
System.out.print(diffMinutes + " minutes, ");
System.out.print(diffSeconds + " seconds.");

Answer 9

जब मैं आपका कार्यक्रम चलाता हूं, तो यह मुझे उस बिंदु तक भी नहीं पहुंचाता है, जहां मैं दूसरी तारीख दर्ज कर सकता हूं।

यह सरल और कम त्रुटि प्रवण है।

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Test001 {

    public static void main(String[] args) throws Exception {

        BufferedReader br = null;

        br = new BufferedReader(new InputStreamReader(System.in));
        SimpleDateFormat sdf = new SimpleDateFormat("dd MM yyyy");

        System.out.println("Insert first date : ");
        Date dt1 = sdf.parse(br.readLine().trim());

        System.out.println("Insert second date : ");
        Date dt2 = sdf.parse(br.readLine().trim());

        long diff = dt2.getTime() - dt1.getTime();

        System.out.println("Days: " + diff / 1000L / 60L / 60L / 24L);

        if (br != null) {
            br.close();
        }
    }
}

Answer 10

// date format, it will be like "2015-01-01"
private static final String DATE_FORMAT = "yyyy-MM-dd";

// convert a string to java.util.Date
public static Date convertStringToJavaDate(String date)
        throws ParseException {
    DateFormat dataFormat = new SimpleDateFormat(DATE_FORMAT);
    return dataFormat.parse(date);
}

// plus days to a date
public static Date plusJavaDays(Date date, int days) {
    // convert to jata-time
    DateTime fromDate = new DateTime(date);
    DateTime toDate = fromDate.plusDays(days);
    // convert back to java.util.Date
    return toDate.toDate();
}

// return a list of dates between the fromDate and toDate
public static List<Date> getDatesBetween(Date fromDate, Date toDate) {
    List<Date> dates = new ArrayList<Date>(0);
    Date date = fromDate;
    while (date.before(toDate) || date.equals(toDate)) {
        dates.add(date);
        date = plusJavaDays(date, 1);
    }
    return dates;
}

Answer 11

हम LocalDate और ChronoUnit जावा लाइब्रेरी का उपयोग कर सकते हैं, नीचे कोड ठीक काम कर रहा है। दिनांक प्रारूप में होना चाहिए yyyy-MM-dd।

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.util.*;
class Solution {
    public int daysBetweenDates(String date1, String date2) {
        LocalDate dt1 = LocalDate.parse(date1);
        LocalDate dt2= LocalDate.parse(date2);

        long diffDays = ChronoUnit.DAYS.between(dt1, dt2);

        return Math.abs((int)diffDays);
    }
}

Comments

योगदान करने के लिए धन्यवाद। मेरा मानना ​​है कि यह अच्छा सुझाव पहले से ही mkobit द्वारा जवाब में प्रस्तुत किया गया था।

— ओले वीवी