जावा में दो तिथियों के बीच अंतर की अवधि कैसे पता करें?

Question

मेरे पास DateTime की दो वस्तुएँ हैं , जिन्हें उनके अंतर की अवधि ज्ञात करने की आवश्यकता है ,

मेरे पास निम्नलिखित कोड है, लेकिन यह सुनिश्चित करने के लिए सुनिश्चित नहीं है कि इसे निम्नलिखित परिणामों के लिए कैसे जारी रखा जाए:

उदाहरण

      11/03/14 09:30:58
      11/03/14 09:33:43
      elapsed time is 02 minutes and 45 seconds
      -----------------------------------------------------
      11/03/14 09:30:58 
      11/03/15 09:30:58
      elapsed time is a day
      -----------------------------------------------------
      11/03/14 09:30:58 
      11/03/16 09:30:58
      elapsed time is two days
      -----------------------------------------------------
      11/03/14 09:30:58 
      11/03/16 09:35:58
      elapsed time is two days and 05 mintues

कोड

    String dateStart = "11/03/14 09:29:58";
    String dateStop = "11/03/14 09:33:43";

    Custom date format
    SimpleDateFormat format = new SimpleDateFormat("yy/MM/dd HH:mm:ss");

    Date d1 = null;
    Date d2 = null;
    try {
        d1 = format.parse(dateStart);
        d2 = format.parse(dateStop);
    } catch (ParseException e) {
        e.printStackTrace();
    }

    // Get msec from each, and subtract.
    long diff = d2.getTime() - d1.getTime();
    long diffSeconds = diff / 1000 % 60;
    long diffMinutes = diff / (60 * 1000) % 60;
    long diffHours = diff / (60 * 60 * 1000);
    System.out.println("Time in seconds: " + diffSeconds + " seconds.");
    System.out.println("Time in minutes: " + diffMinutes + " minutes.");
    System.out.println("Time in hours: " + diffHours + " hours.");

Comments

कृपया जोडा समय पर एक नजर डालें, जिसने इसके लिए समर्थन में निर्माण किया है।

— एरिक प्रगट

आपके साथ गलत क्या है, आपको आवश्यक आउटपुट प्राप्त करने के लिए बस कुछ

— ट्वीक्स

पहले घंटे में अंतर ढूंढें, शेष मिनट और फिर सेकंड में अंतर खोजें!

— NINCOMPOOP

@PeterLawrey मैंने अलग-अलग उदाहरण दिए हैं

— J888

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

— टिम नॉर्मन

Answer 1

निम्नलिखित प्रयास करें

{
        Date dt2 = new DateAndTime().getCurrentDateTime();

        long diff = dt2.getTime() - dt1.getTime();
        long diffSeconds = diff / 1000 % 60;
        long diffMinutes = diff / (60 * 1000) % 60;
        long diffHours = diff / (60 * 60 * 1000);
        int diffInDays = (int) ((dt2.getTime() - dt1.getTime()) / (1000 * 60 * 60 * 24));

        if (diffInDays > 1) {
            System.err.println("Difference in number of days (2) : " + diffInDays);
            return false;
        } else if (diffHours > 24) {

            System.err.println(">24");
            return false;
        } else if ((diffHours == 24) && (diffMinutes >= 1)) {
            System.err.println("minutes");
            return false;
        }
        return true;
}

Comments

यह उत्तर समय क्षेत्रों की अनदेखी करता है जो दिनों की शुरुआत और समाप्ति को परिभाषित करता है। यह उत्तर डेलाइट सेविंग टाइम और अन्य विसंगतियों को नजरअंदाज करता है, जिसका मतलब है कि एक दिन हमेशा लंबाई में 24 घंटे नहीं होता है। सही उत्तर देखें जो या तो Joda-Time या java.time पुस्तकालयों का उपयोग करते हैं।

— तुलसी बॉर्क

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

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

Answer 2

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

Date startDate = // Set start date
Date endDate   = // Set end date

long duration  = endDate.getTime() - startDate.getTime();

long diffInSeconds = TimeUnit.MILLISECONDS.toSeconds(duration);
long diffInMinutes = TimeUnit.MILLISECONDS.toMinutes(duration);
long diffInHours = TimeUnit.MILLISECONDS.toHours(duration);
long diffInDays = TimeUnit.MILLISECONDS.toDays(duration);

Comments

वैकल्पिक रूप से लंबे समय तक अंतर

— जेरार्ड

यह सबसे अच्छा जवाब है।

— एंजेल क्वेंका

मैं दूसरी गति; यह उत्तर सबसे अच्छा है।

— मुशी सिप

3 पार्टी लाइब्रेरी पर कोई निर्भरता नहीं।

— crmepham

हाय सबसे पहले आप सभी को आपके लघु और अच्छे उत्तर के लिए बहुत बहुत धन्यवाद, मैं आपके समाधान पर एक समस्या का सामना कर रहा हूं जैसे कि मेरे पास दो तारीखें हैं 06_12_2017_07_18_02_PM और दूसरा है 06_12_2017-07_13_16_PM, मुझे 286 सेकंड मिल रहे हैं बजाय मुझे केवल 46 सेकंड में मिलना चाहिए

— सिद्धपुरा अमित

Answer 3

जोडा-टाइम लाइब्रेरी का उपयोग करें

DateTime startTime, endTime;
Period p = new Period(startTime, endTime);
long hours = p.getHours();
long minutes = p.getMinutes();

Joda Time में समय की अवधारणा है:

Interval interval = new Interval(oldTime, new Instant());

एक और उदाहरण दिनांक अंतर

एक और लिंक

या जावा -8 के साथ (जो जोडा-टाइम अवधारणाओं को एकीकृत करता है)

Instant start, end;//
Duration dur = Duration.between(start, stop);
long hours = dur.toHours();
long minutes = dur.toMinutes();

Comments

यह स्वीकृत उत्तर होना चाहिए। जोडा समय जाने का रास्ता है

— बिज्मर्क

ठीक से

— टाइमज़ोन

बस एक छोटा टाइपो: आपका मतलब था कि आपकी दूसरी पंक्ति में "अंत" नहीं "स्टॉप" ("ड्यूरेशन ड्यूर = ड्यूरेशन.बेटन (स्टार्ट, स्टॉप);")।

— मोहम्मद फकीह

Answer 4

यहाँ बताया गया है कि समस्या का हल जावा 8 में शमिमज़ द्वारा उत्तर की तरह ही किया जा सकता है।

स्रोत: http://docs.oracle.com/javase/tutorial/datetime/iso/period.html

LocalDate today = LocalDate.now();
LocalDate birthday = LocalDate.of(1960, Month.JANUARY, 1);

Period p = Period.between(birthday, today);
long p2 = ChronoUnit.DAYS.between(birthday, today);

System.out.println("You are " + p.getYears() + " years, " + p.getMonths() + " months, and " + p.getDays() + " days old. (" + p2 + " days total)");

कोड निम्न के समान आउटपुट उत्पन्न करता है:

You are 53 years, 4 months, and 29 days old. (19508 days total)

हमें घंटे, मिनट, दूसरे अंतर प्राप्त करने के लिए LocalDateTime http://docs.oracle.com/javase/8/docs/api/java/time/LocalDateTime.html का उपयोग करना होगा ।

Comments

यह इतना जोडा-टाइम तरीका है जैसा कि मयूरबी द्वारा उत्तर दिया गया है। joda-time.sourceforge.net

— johnkarka

आपका जोडा-टाइम से लिंक पुराना है। वर्तमान URL joda.org/joda-time

— तुलसी बॉर्क

लोकलडेट समय और समय क्षेत्र का भंडारण नहीं कर रहा है। यह केवल दिन-महीने-वर्ष रखता है। देखें docs.oracle.com/javase/8/docs/api/java/time/LocalDate.html

— शमीम अहमद

यह समय को ध्यान में नहीं रखता है। ओपी के प्रश्न में सेकंड, मिनट और घंटे थे।

— mkobit

Answer 5

Date d2 = new Date();
Date d1 = new Date(1384831803875l);

long diff = d2.getTime() - d1.getTime();
long diffSeconds = diff / 1000 % 60;
long diffMinutes = diff / (60 * 1000) % 60;
long diffHours = diff / (60 * 60 * 1000);
int diffInDays = (int) diff / (1000 * 60 * 60 * 24);

System.out.println(diffInDays+"  days");
System.out.println(diffHours+"  Hour");
System.out.println(diffMinutes+"  min");
System.out.println(diffSeconds+"  sec");

Comments

हाय सबसे पहले आप सभी को आपके लघु और अच्छे उत्तर के लिए बहुत बहुत धन्यवाद, मैं आपके समाधान पर एक समस्या का सामना कर रहा हूं जैसे कि मेरे पास दो तारीखें हैं 06_12_2017_07_18_02_PM और दूसरा है 06_12_2017-07_13_16_PM, मुझे 286 सेकंड मिल रहे हैं बजाय मुझे केवल 46 सेकंड में मिलना चाहिए

— सिद्धपुरा अमित

Answer 6

आप जैसी विधि बना सकते हैं

public long getDaysBetweenDates(Date d1, Date d2){
return TimeUnit.MILLISECONDS.toDays(d1.getTime() - d2.getTime());
}

यह विधि 2 दिनों के बीच दिनों की संख्या वापस कर देगी।

Answer 7

जैसा कि माइकल Borgwardt यहाँ अपने जवाब में लिखते हैं :

int diffInDays = (int)( (newerDate.getTime() - olderDate.getTime()) 
                 / (1000 * 60 * 60 * 24) )

ध्यान दें कि यह UTC तिथियों के साथ काम करता है, इसलिए यदि आप स्थानीय तिथियों को देखते हैं तो अंतर एक दिन का हो सकता है। और इसे स्थानीय तारीखों के साथ सही ढंग से काम करने के लिए दिन के समय की बचत के कारण पूरी तरह से अलग दृष्टिकोण की आवश्यकता होती है।

Comments

इन मूल्य को मैन्युअल रूप से गुणा करना अच्छा नहीं है। बल्कि ऐसा करने के लिए java TimeUnit क्लास का उपयोग करें।

— शमीम अहमद

स्थानीय तिथियों के संबंध में आप जो कहते हैं वह सच नहीं है। एपीआई डेट के अनुसार गेटटाइम () विधि, 1 जनवरी 1970 से मिलीसेकंड की संख्या लौटाती है, इस तिथि ऑब्जेक्ट द्वारा दर्शाए गए GMT 00:00:00 GMT। यदि दो संख्याओं में एक ही इकाई है, तो उन्हें जोड़ना और घटाना सुरक्षित है।

— इंगो

हाँ। यह सुरक्षित है लेकिन कोड साफ नहीं है क्योंकि जावा इसे संभालने के लिए मानक तरीका प्रदान करता है।

— शमीम अहमद

एक उत्तर के लिए एक लिंक प्रदान करने के अलावा, आपको स्पष्ट रूप से शब्दों को उद्धृत करना होगा जिसे आपने दूसरों से कॉपी किया है।

— ब्रैड लार्सन

Answer 8

जावा 8 में, आप , और DateTimeFormatter, का बना सकते हैं । यहाँ एक उदाहरण है:DurationLocalDateTime

final String dateStart = "11/03/14 09:29:58";
final String dateStop = "11/03/14 09:33:43";

final DateTimeFormatter formatter = new DateTimeFormatterBuilder()
        .appendValue(ChronoField.MONTH_OF_YEAR, 2)
        .appendLiteral('/')
        .appendValue(ChronoField.DAY_OF_MONTH, 2)
        .appendLiteral('/')
        .appendValueReduced(ChronoField.YEAR, 2, 2, 2000)
        .appendLiteral(' ')
        .appendValue(ChronoField.HOUR_OF_DAY, 2)
        .appendLiteral(':')
        .appendValue(ChronoField.MINUTE_OF_HOUR, 2)
        .appendLiteral(':')
        .appendValue(ChronoField.SECOND_OF_MINUTE, 2)
        .toFormatter();

final LocalDateTime start = LocalDateTime.parse(dateStart, formatter);
final LocalDateTime stop = LocalDateTime.parse(dateStop, formatter);

final Duration between = Duration.between(start, stop);

System.out.println(start);
System.out.println(stop);
System.out.println(formatter.format(start));
System.out.println(formatter.format(stop));
System.out.println(between);
System.out.println(between.get(ChronoUnit.SECONDS));

Answer 9

यह मेरे लिए काम कर सकता है इस के साथ, आशा है कि यह मददगार होगा। अगर कोई चिंता है तो मुझे बताएं।

Date startDate = java.util.Calendar.getInstance().getTime(); //set your start time
Date endDate = java.util.Calendar.getInstance().getTime(); // set  your end time

long duration = endDate.getTime() - startDate.getTime();


long diffInSeconds = TimeUnit.MILLISECONDS.toSeconds(duration);
long diffInMinutes = TimeUnit.MILLISECONDS.toMinutes(duration);
long diffInHours = TimeUnit.MILLISECONDS.toHours(duration);
long diffInDays = TimeUnit.MILLISECONDS.toDays(duration);

Toast.makeText(MainActivity.this, "Diff"
        + duration + diffInDays + diffInHours + diffInMinutes + diffInSeconds, Toast.LENGTH_SHORT).show(); **// Toast message for android .**

System.out.println("Diff" + duration + diffInDays + diffInHours + diffInMinutes + diffInSeconds); **// Print console message for Java .**

Comments

long diffInSeconds = TimeUnit.MILLISECONDS.toSeconds (अवधि);

— केशव गेरा

Answer 10

यह कोड है:

        String date1 = "07/15/2013";
        String time1 = "11:00:01";
        String date2 = "07/16/2013";
        String time2 = "22:15:10";
        String format = "MM/dd/yyyy HH:mm:ss";
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date fromDate = sdf.parse(date1 + " " + time1);
        Date toDate = sdf.parse(date2 + " " + time2);

        long diff = toDate.getTime() - fromDate.getTime();
        String dateFormat="duration: ";
        int diffDays = (int) (diff / (24 * 60 * 60 * 1000));
        if(diffDays>0){
            dateFormat+=diffDays+" day ";
        }
        diff -= diffDays * (24 * 60 * 60 * 1000);

        int diffhours = (int) (diff / (60 * 60 * 1000));
        if(diffhours>0){
            dateFormat+=diffhours+" hour ";
        }
        diff -= diffhours * (60 * 60 * 1000);

        int diffmin = (int) (diff / (60 * 1000));
        if(diffmin>0){
            dateFormat+=diffmin+" min ";
        }
        diff -= diffmin * (60 * 1000);

        int diffsec = (int) (diff / (1000));
        if(diffsec>0){
            dateFormat+=diffsec+" sec";
        }
        System.out.println(dateFormat);

और बाहर है:

duration: 1 day 11 hour 15 min 9 sec

Answer 11

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

public static String getDurationTimeStamp(String date) {

        String timeDifference = "";

        //date formatter as per the coder need
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        //parse the string date-ti
        // me to Date object
        Date startDate = null;
        try {
            startDate = sdf.parse(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }

        //end date will be the current system time to calculate the lapse time difference
        //if needed, coder can add end date to whatever date
        Date endDate = new Date();

        System.out.println(startDate);
        System.out.println(endDate);

        //get the time difference in milliseconds
        long duration = endDate.getTime() - startDate.getTime();

        //now we calculate the differences in different time units
        //this long value will be the total time difference in each unit
        //i.e; total difference in seconds, total difference in minutes etc...
        long diffInSeconds = TimeUnit.MILLISECONDS.toSeconds(duration);
        long diffInMinutes = TimeUnit.MILLISECONDS.toMinutes(duration);
        long diffInHours = TimeUnit.MILLISECONDS.toHours(duration);
        long diffInDays = TimeUnit.MILLISECONDS.toDays(duration);

        //now we create the time stamps depending on the value of each unit that we get
        //as we do not have the unit in years,
        //we will see if the days difference is more that 365 days, as 365 days = 1 year
        if (diffInDays > 365) {
            //we get the year in integer not in float
            //ex- 791/365 = 2.167 in float but it will be 2 years in int
            int year = (int) (diffInDays / 365);
            timeDifference = year + " years ago";
            System.out.println(year + " years ago");
        }
        //if days are not enough to create year then get the days
        else if (diffInDays > 1) {
            timeDifference = diffInDays + " days ago";
            System.out.println(diffInDays + " days ago");
        }
        //if days value<1 then get the hours
        else if (diffInHours > 1) {
            timeDifference = diffInHours + " hours ago";
            System.out.println(diffInHours + " hours ago");
        }
        //if hours value<1 then get the minutes
        else if (diffInMinutes > 1) {
            timeDifference = diffInMinutes + " minutes ago";
            System.out.println(diffInMinutes + " minutes ago");
        }
        //if minutes value<1 then get the seconds
        else if (diffInSeconds > 1) {
            timeDifference = diffInSeconds + " seconds ago";
            System.out.println(diffInSeconds + " seconds ago");
        }

        return timeDifference;
// that's all. Happy Coding :)
    }

Answer 12

मैंने हाल ही में एक सरल विधि का उपयोग करके इसी तरह की समस्या को हल किया।

public static void main(String[] args) throws IOException, ParseException {
        TimeZone utc = TimeZone.getTimeZone("UTC");
        Calendar calendar = Calendar.getInstance(utc);
        Date until = calendar.getTime();
        calendar.add(Calendar.DAY_OF_MONTH, -7);
        Date since = calendar.getTime();
        long durationInSeconds  = TimeUnit.MILLISECONDS.toSeconds(until.getTime() - since.getTime());

        long SECONDS_IN_A_MINUTE = 60;
        long MINUTES_IN_AN_HOUR = 60;
        long HOURS_IN_A_DAY = 24;
        long DAYS_IN_A_MONTH = 30;
        long MONTHS_IN_A_YEAR = 12;

        long sec = (durationInSeconds >= SECONDS_IN_A_MINUTE) ? durationInSeconds % SECONDS_IN_A_MINUTE : durationInSeconds;
        long min = (durationInSeconds /= SECONDS_IN_A_MINUTE) >= MINUTES_IN_AN_HOUR ? durationInSeconds%MINUTES_IN_AN_HOUR : durationInSeconds;
        long hrs = (durationInSeconds /= MINUTES_IN_AN_HOUR) >= HOURS_IN_A_DAY ? durationInSeconds % HOURS_IN_A_DAY : durationInSeconds;
        long days = (durationInSeconds /= HOURS_IN_A_DAY) >= DAYS_IN_A_MONTH ? durationInSeconds % DAYS_IN_A_MONTH : durationInSeconds;
        long months = (durationInSeconds /=DAYS_IN_A_MONTH) >= MONTHS_IN_A_YEAR ? durationInSeconds % MONTHS_IN_A_YEAR : durationInSeconds;
        long years = (durationInSeconds /= MONTHS_IN_A_YEAR);

        String duration = getDuration(sec,min,hrs,days,months,years);
        System.out.println(duration);
    }
    private static String getDuration(long secs, long mins, long hrs, long days, long months, long years) {
        StringBuffer sb = new StringBuffer();
        String EMPTY_STRING = "";
        sb.append(years > 0 ? years + (years > 1 ? " years " : " year "): EMPTY_STRING);
        sb.append(months > 0 ? months + (months > 1 ? " months " : " month "): EMPTY_STRING);
        sb.append(days > 0 ? days + (days > 1 ? " days " : " day "): EMPTY_STRING);
        sb.append(hrs > 0 ? hrs + (hrs > 1 ? " hours " : " hour "): EMPTY_STRING);
        sb.append(mins > 0 ? mins + (mins > 1 ? " mins " : " min "): EMPTY_STRING);
        sb.append(secs > 0 ? secs + (secs > 1 ? " secs " : " secs "): EMPTY_STRING);
        sb.append("ago");
        return sb.toString();
    }

और जैसा कि उम्मीद थी यह प्रिंट 7 days ago:।

Answer 13

यह एक कार्यक्रम है जो मैंने लिखा है, जिसमें 2 तारीखों के बीच दिनों की संख्या मिलती है (यहां कोई समय नहीं)।

import java.util.Scanner;
public class HelloWorld {
 public static void main(String args[]) {
  Scanner s = new Scanner(System.in);
  System.out.print("Enter starting date separated by dots: ");
  String inp1 = s.nextLine();
  System.out.print("Enter ending date separated by dots: ");
  String inp2 = s.nextLine();
  int[] nodim = {
   0,
   31,
   28,
   31,
   30,
   31,
   30,
   31,
   31,
   30,
   31,
   30,
   31
  };
  String[] inpArr1 = split(inp1);
  String[] inpArr2 = split(inp2);
  int d1 = Integer.parseInt(inpArr1[0]);
  int m1 = Integer.parseInt(inpArr1[1]);
  int y1 = Integer.parseInt(inpArr1[2]);
  int d2 = Integer.parseInt(inpArr2[0]);
  int m2 = Integer.parseInt(inpArr2[1]);
  int y2 = Integer.parseInt(inpArr2[2]);
  if (y1 % 4 == 0) nodim[2] = 29;
  int diff = m1 == m2 && y1 == y2 ? d2 - (d1 - 1) : (nodim[m1] - (d1 - 1));
  int mm1 = m1 + 1, mm2 = m2 - 1, yy1 = y1, yy2 = y2;
  for (; yy1 <= yy2; yy1++, mm1 = 1) {
   mm2 = yy1 == yy2 ? (m2 - 1) : 12;
   if (yy1 % 4 == 0) nodim[2] = 29;
   else nodim[2] = 28;
   if (mm2 == 0) {
    mm2 = 12;
    yy2 = yy2 - 1;
   }
   for (; mm1 <= mm2 && yy1 <= yy2; mm1++) diff = diff + nodim[mm1];
  }
  System.out.print("No. of days from " + inp1 + " to " + inp2 + " is " + diff);
 }
 public static String[] split(String s) {
  String[] retval = {
   "",
   "",
   ""
  };
  s = s + ".";
  s = s + " ";
  for (int i = 0; i <= 2; i++) {
   retval[i] = s.substring(0, s.indexOf("."));
   s = s.substring((s.indexOf(".") + 1), s.length());
  }
  return retval;
 }
}

http://pastebin.com/HRsjTtUf

Answer 14

   // calculating the difference b/w startDate and endDate
        String startDate = "01-01-2016";
        String endDate = simpleDateFormat.format(currentDate);

        date1 = simpleDateFormat.parse(startDate);
        date2 = simpleDateFormat.parse(endDate);

        long getDiff = date2.getTime() - date1.getTime();

        // using TimeUnit class from java.util.concurrent package
        long getDaysDiff = TimeUnit.MILLISECONDS.toDays(getDiff);

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