Java에서 날짜/시간 차이 계산

Java에서 날짜/시간 차이 계산

이 질문에는 이미 다음과 같은 해답이 있다.

Java에서 Mills를 "Xmins, x초"로 변환하는 방법? (28개 답변)

닫힌6년 전.

나는 두 날짜의 차이를 시간/분/초 단위로 계산하고 싶다.

여기 내 코드에 약간의 문제가 있다:

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;         
long diffMinutes = diff / (60 * 1000);         
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."); 

이것은 다음을 생성해야 한다.

Time in seconds: 45 seconds.
Time in minutes: 3 minutes.
Time in hours: 0 hours.

그러나 나는 이 결과를 얻는다.

Time in seconds: 225 seconds.
Time in minutes: 3 minutes.
Time in hours: 0 hours.

내가 뭘 잘못하고 있는지 누가 알겠어?

나는 제안을 사용하는 것을 선호한다.java.util.concurrent.TimeUnit학급

long diff = d2.getTime() - d1.getTime();//as given

long seconds = TimeUnit.MILLISECONDS.toSeconds(diff);
long minutes = TimeUnit.MILLISECONDS.toMinutes(diff); 

해보다

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

메모:이것은 가정한다diffnon-negative 있다.

만약 당신이 외부 라이브러리를 사용할 수 있다면, 나는 당신이 Joda-Time을 사용할 것을 추천하고 싶다.

Joda-Time은 Java SE 8 이전의 자바에 대한 사실상의 표준 날짜 및 시간 라이브러리로서, 사용자는 이제 Java.time(JSR-310)으로 마이그레이션하도록 요청받는다.

중간 계산 예제:

Seconds.between(startDate, endDate);
Days.between(startDate, endDate);

자바 5부터는 코드에 1000과 60과 같은 매직넘버를 사용하지 않도록 할 수 있다.

그런데 계산에서 초를 도약하는 데 주의해야 한다. 1년의 마지막 순간은 추가 초를 가질 수 있기 때문에 예상된 60초가 아니라 61초 동안 지속된다.ISO 규격은 61초까지 계획한다.자세한 것은 자바독에서 찾을 수 있다.

시간 차이를 밀리초 단위로 친숙하게 표현해 보십시오.

String friendlyTimeDiff(long timeDifferenceMilliseconds) {
    long diffSeconds = timeDifferenceMilliseconds / 1000;
    long diffMinutes = timeDifferenceMilliseconds / (60 * 1000);
    long diffHours = timeDifferenceMilliseconds / (60 * 60 * 1000);
    long diffDays = timeDifferenceMilliseconds / (60 * 60 * 1000 * 24);
    long diffWeeks = timeDifferenceMilliseconds / (60 * 60 * 1000 * 24 * 7);
    long diffMonths = (long) (timeDifferenceMilliseconds / (60 * 60 * 1000 * 24 * 30.41666666));
    long diffYears = timeDifferenceMilliseconds / ((long)60 * 60 * 1000 * 24 * 365);

    if (diffSeconds < 1) {
        return "less than a second";
    } else if (diffMinutes < 1) {
        return diffSeconds + " seconds";
    } else if (diffHours < 1) {
        return diffMinutes + " minutes";
    } else if (diffDays < 1) {
        return diffHours + " hours";
    } else if (diffWeeks < 1) {
        return diffDays + " days";
    } else if (diffMonths < 1) {
        return diffWeeks + " weeks";
    } else if (diffYears < 1) {
        return diffMonths + " months";
    } else {
        return diffYears + " years";
    }
}

이것은 기본적으로 자바 문제라기 보다는 수학 문제에 가깝다.

당신이 받은 결과는 정확하다.225초는 3분(적분할을 할 때)이기 때문이다.원하는 것은 다음과 같다.

• 1000으로 나누어서 초 수를 얻는다 -> 휴식은 밀리초이다.
• 그것을 60으로 나누어서 분수를 구한다 -> 휴식은 초이다.
• 그것을 60으로 나누어서 시간수를 구하라 -> 휴식은 분이다.

또는 자바:

int millis = diff % 1000;
diff/=1000;
int seconds = diff % 60;
diff/=60;
int minutes = diff % 60;
diff/=60;
hours = diff;

여기의 제안을 사용하고 있다.TimeUnit각 시간 부품을 구하여 포맷한다.

private static String formatDuration(long duration) {
    long hours = TimeUnit.MILLISECONDS.toHours(duration);
    long minutes = TimeUnit.MILLISECONDS.toMinutes(duration) % 60;
    long seconds = TimeUnit.MILLISECONDS.toSeconds(duration) % 60;
    long milliseconds = duration % 1000;
    return String.format("%02d:%02d:%02d,%03d", hours, minutes, seconds, milliseconds);
}

SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss,SSS");
Date startTime = sdf.parse("01:00:22,427");
Date now = sdf.parse("02:06:38,355");
long duration = now.getTime() - startTime.getTime();
System.out.println(formatDuration(duration));

결과: 01:06:15,928

이게 오래된 질문인 건 알지만, 나는 결국 받아들여진 대답과는 약간 다른 일을 하게 되었다.사람들은 그것에 대해 이야기한다.TimeUnitclass, 그러나 OP가 원하는 방식으로 이것을 사용하는 답은 없었다.

그래서 여기에 또 다른 해결책이 있는데, 만약 누군가가 그것을 놓쳐서 온다면;-)

public class DateTesting {
    public static void main(String[] args) {
        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 days = TimeUnit.MILLISECONDS.toDays(diff);
        long remainingHoursInMillis = diff - TimeUnit.DAYS.toMillis(days);
        long hours = TimeUnit.MILLISECONDS.toHours(remainingHoursInMillis);
        long remainingMinutesInMillis = remainingHoursInMillis - TimeUnit.HOURS.toMillis(hours);
        long minutes = TimeUnit.MILLISECONDS.toMinutes(remainingMinutesInMillis);
        long remainingSecondsInMillis = remainingMinutesInMillis - TimeUnit.MINUTES.toMillis(minutes);
        long seconds = TimeUnit.MILLISECONDS.toSeconds(remainingSecondsInMillis);

        System.out.println("Days: " + days + ", hours: " + hours + ", minutes: " + minutes + ", seconds: " + seconds);
    }
}

비록 자신을 단지 차이를 계산 할 수 있는 것이 그 모습을 보고매우 그것을 해야 하고 나는차액을 스스로 계산하는 것만으로 할 수 있지만 그렇게 하는 것은 큰 의미가 없고, 내 생각에 그렇게 하는 것 같다 것 같아 의미 있는 아니다.TimeUnit있나 대단히 무시되는 클래스입니다.매우 간과되는 수업이다.

한 만들기 만들기Date개체 생성자로 때의 다른 점은 무엇을 사용하여, 생성자로서 당신의 시대 사이의 차이를 사용하는 객체,.
그리고 달력 메서드 값을 가져오다. use.그런 다음 달력사용하여 값을 얻으십시오 method를.

Date diff = new Date(d2.getTime() - d1.getTime());

Calendar calendar = Calendar.getInstance();
calendar.setTime(diff);
int hours = calendar.get(Calendar.HOUR_OF_DAY);
int minutes = calendar.get(Calendar.MINUTE);
int seconds = calendar.get(Calendar.SECOND);

쌍방간의 차이

링크에서 코드 추출

public class TimeDiff {
    /**
     * (For testing purposes)
     *
     */
    public static void main(String[] args) {
        Date d1 = new Date();
        try { Thread.sleep(750); } catch(InterruptedException e) { /* ignore */ }      
        Date d0 = new Date(System.currentTimeMillis() - (1000*60*60*24*3)); // About 3 days ago
        long[] diff = TimeDiff.getTimeDifference(d0, d1);

        System.out.printf("Time difference is %d day(s), %d hour(s), %d minute(s), %d second(s) and %d millisecond(s)\n",
                diff[0], diff[1], diff[2], diff[3], diff[4]);
        System.out.printf("Just the number of days = %d\n",
                TimeDiff.getTimeDifference(d0, d1, TimeDiff.TimeField.DAY));
    }

    /**
     * Calculate the absolute difference between two Date without
     * regard for time offsets
     *
     * @param d1 Date one
     * @param d2 Date two
     * @param field The field we're interested in out of
     * day, hour, minute, second, millisecond
     *
     * @return The value of the required field
     */
    public static long getTimeDifference(Date d1, Date d2, TimeField field) {
        return TimeDiff.getTimeDifference(d1, d2)[field.ordinal()];
    }

    /**
     * Calculate the absolute difference between two Date without
     * regard for time offsets
     *
     * @param d1 Date one
     * @param d2 Date two
     * @return The fields day, hour, minute, second and millisecond
     */
    public static long[] getTimeDifference(Date d1, Date d2) {
        long[] result = new long[5];
        Calendar cal = Calendar.getInstance();
        cal.setTimeZone(TimeZone.getTimeZone("UTC"));
        cal.setTime(d1);

        long t1 = cal.getTimeInMillis();
        cal.setTime(d2);

        long diff = Math.abs(cal.getTimeInMillis() - t1);
        final int ONE_DAY = 1000 * 60 * 60 * 24;
        final int ONE_HOUR = ONE_DAY / 24;
        final int ONE_MINUTE = ONE_HOUR / 60;
        final int ONE_SECOND = ONE_MINUTE / 60;

        long d = diff / ONE_DAY;
        diff %= ONE_DAY;

        long h = diff / ONE_HOUR;
        diff %= ONE_HOUR;

        long m = diff / ONE_MINUTE;
        diff %= ONE_MINUTE;

        long s = diff / ONE_SECOND;
        long ms = diff % ONE_SECOND;
        result[0] = d;
        result[1] = h;
        result[2] = m;
        result[3] = s;
        result[4] = ms;

        return result;
    }

    public static void printDiffs(long[] diffs) {
        System.out.printf("Days:         %3d\n", diffs[0]);
        System.out.printf("Hours:        %3d\n", diffs[1]);
        System.out.printf("Minutes:      %3d\n", diffs[2]);
        System.out.printf("Seconds:      %3d\n", diffs[3]);
        System.out.printf("Milliseconds: %3d\n", diffs[4]);
    }

    public static enum TimeField {DAY,
        HOUR,
        MINUTE,
        SECOND,
        MILLISECOND;
    }
}

// d1, d2 are dates
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.");

조다 타임

Joda-Time 2.3 도서관은 이 안무를 위해 이미 디버깅된 코드를 제공한다.

Joad-Time은 시간 범위를 나타내는 세 가지 클래스를 포함한다.Interval그리고.Duration..Period월, 일, 시간, 등(시간 표시 막대에 얽매이지 않)의 숫자로 한뼘을 추적합니다.(연대표에 연결되지 않은)월, 일,스팬을 추적한다 수로시간 등의.

// © 2013 Basil Bourque. This source code may be used freely forever by anyone taking full responsibility for doing so.

// Specify a time zone rather than rely on default.
// Necessary to handle Daylight Saving Time (DST) and other anomalies.
DateTimeZone timeZone = DateTimeZone.forID( "America/Montreal" );

DateTimeFormatter formatter = DateTimeFormat.forPattern( "yy/MM/dd HH:mm:ss" ).withZone( timeZone ); 

DateTime dateTimeStart = formatter.parseDateTime( "11/03/14 09:29:58" );
DateTime dateTimeStop = formatter.parseDateTime( "11/03/14 09:33:43" );
Period period = new Period( dateTimeStart, dateTimeStop );

PeriodFormatter periodFormatter = PeriodFormat.getDefault();
String output = periodFormatter.print( period );

System.out.println( "output: " + output );

실행 시…

output: 3 minutes and 45 seconds

여기 내 암호야.

import java.util.Date;

// to calculate difference between two days
public class DateDifference {

// to calculate difference between two dates in milliseconds
public long getDateDiffInMsec(Date da, Date db) {
    long diffMSec = 0;
    diffMSec = db.getTime() - da.getTime();
    return diffMSec;
}

// to convert Milliseconds into DD HH:MM:SS format.
public String getDateFromMsec(long diffMSec) {
    int left = 0;
    int ss = 0;
    int mm = 0;
    int hh = 0;
    int dd = 0;
    left = (int) (diffMSec / 1000);
    ss = left % 60;
    left = (int) left / 60;
    if (left > 0) {
        mm = left % 60;
        left = (int) left / 60;
        if (left > 0) {
            hh = left % 24;
            left = (int) left / 24;
            if (left > 0) {
                dd = left;
            }
        }
    }
    String diff = Integer.toString(dd) + " " + Integer.toString(hh) + ":"
            + Integer.toString(mm) + ":" + Integer.toString(ss);
    return diff;

}
}

긴 diffSeconds, 긴 diffSeconds(연락/1000)%60정도,(연락/1000)%60정도씩 생겨나고 있다.
그리고 사실 아주 제대로 작동하는지를 알려 주세요 이렇게 해 보세요...이것을 시도해보고 그것이 제대로 작동하는지 나에게 알려달라...

음, 다른 코드 샘플로 해볼게.

/**
 * Calculates the number of FULL days between to dates
 * @param startDate must be before endDate
 * @param endDate must be after startDate
 * @return number of day between startDate and endDate
 */
public static int daysBetween(Calendar startDate, Calendar endDate) {
    long start = startDate.getTimeInMillis();
    long end = endDate.getTimeInMillis();
    // It's only approximation due to several bugs (@see java.util.Date) and different precision in Calendar chosen
    // by user (ex. day is time-quantum).
    int presumedDays = (int) TimeUnit.MILLISECONDS.toDays(end - start);
    startDate.add(Calendar.DAY_OF_MONTH, presumedDays);
    // if we still didn't reach endDate try it with the step of one day
    if (startDate.before(endDate)) {
        startDate.add(Calendar.DAY_OF_MONTH, 1);
        ++presumedDays;
    }
    // if we crossed endDate then we must go back, because the boundary day haven't completed yet
    if (startDate.after(endDate)) {
        --presumedDays;
    }
    return presumedDays;
}

Date startTime = new Date();
//...
//... lengthy jobs
//...
Date endTime = new Date();
long diff = endTime.getTime() - startTime.getTime();
String hrDateText = DurationFormatUtils.formatDuration(diff, "d 'day(s)' H 'hour(s)' m 'minute(s)' s 'second(s)' ");
System.out.println("Duration : " + hrDateText);

Apache Commons Duration Format Utils를 사용할 수 있다.SimpleDateFormatter와 같은 형식

출력:출력:

0 days(s) 0 hour(s) 0 minute(s) 1 second(s)

앞에서 말한 바와 같이 - 이것이 좋은 대답이라고 생각한다.

/**
 * @param d2 the later date 
 * @param d1 the earlier date
 * @param timeUnit - Example Calendar.HOUR_OF_DAY
 * @return
 */
public static int getTimeDifference(Date d2,Date d1, int timeUnit) {
     Date diff = new Date(d2.getTime() - d1.getTime());

     Calendar calendar = Calendar.getInstance();
     calendar.setTime(diff);
     int hours = calendar.get(Calendar.HOUR_OF_DAY);
     int minutes = calendar.get(Calendar.MINUTE);
     int seconds = calendar.get(Calendar.SECOND);
     if(timeUnit==Calendar.HOUR_OF_DAY)
         return hours;
     if(timeUnit==Calendar.MINUTE)
         return minutes;
     return seconds;
 }

참조URL: https://stackoverflow.com/questions/5351483/calculate-date-time-difference-in-java