계산의 차이를 두 Java 날짜를 인스턴스

StackOverflow https://stackoverflow.com/questions/1555262

문제

내가 사용하는 자바의 java.util.Date 클래스에서는 스칼라와 비교하고 싶 Date 객체 및 현재 시간입니다.내가 계산할 수 있습니다 델타 사용하여 getTime():

(new java.util.Date()).getTime() - oldDate.getTime()

그러나,이것은 다만 나와 long 을 나타내는 밀리초 단위입니다.은 없는 간단하고,더 좋은 방법은 시간 delta?

도움이 되었습니까?

해결책

JDK Date API는 불행히도 끔찍하게 부러졌습니다. 사용하는 것이 좋습니다 조다 타임 라이브러리.

Joda Time은 시간의 개념을 가지고 있습니다 간격:

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

편집 : 그건 그렇고, Joda는 두 가지 개념을 가지고 있습니다. Interval 두 시간 순간 사이의 시간 간격 (오전 8시에서 10시 사이의 시간)과 Duration 그것은 실제 시간 경계가없는 시간을 나타냅니다 (예 : 2 시간을 나타냅니다!)

시간 비교에만 관심이 있다면 대부분 Date 구현 (JDK One 포함)은 구현됩니다 Comparable 당신이 당신이 사용할 수있는 인터페이스 Comparable.compareTo()

다른 팁

간단한 차이 (lib 없음)

/**
 * Get a diff between two dates
 * @param date1 the oldest date
 * @param date2 the newest date
 * @param timeUnit the unit in which you want the diff
 * @return the diff value, in the provided unit
 */
public static long getDateDiff(Date date1, Date date2, TimeUnit timeUnit) {
    long diffInMillies = date2.getTime() - date1.getTime();
    return timeUnit.convert(diffInMillies,TimeUnit.MILLISECONDS);
}

그런 다음 전화 할 수 있습니다.

getDateDiff(date1,date2,TimeUnit.MINUTES);

2 분 단위의 2 날짜의 차이를 얻으려면.

TimeUnit ~이다 java.util.concurrent.TimeUnit, 표준 Java 열거는 나노에서 며칠로 이동합니다.

인간 읽기 가능한 차이 (lib 없음)

public static Map<TimeUnit,Long> computeDiff(Date date1, Date date2) {

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

    //create the list
    List<TimeUnit> units = new ArrayList<TimeUnit>(EnumSet.allOf(TimeUnit.class));
    Collections.reverse(units);

    //create the result map of TimeUnit and difference
    Map<TimeUnit,Long> result = new LinkedHashMap<TimeUnit,Long>();
    long milliesRest = diffInMillies;

    for ( TimeUnit unit : units ) {

        //calculate difference in millisecond 
        long diff = unit.convert(milliesRest,TimeUnit.MILLISECONDS);
        long diffInMilliesForUnit = unit.toMillis(diff);
        milliesRest = milliesRest - diffInMilliesForUnit;

        //put the result in the map
        result.put(unit,diff);
    }

    return result;
}

http://ideone.com/5dxeu6

출력은 같은 것입니다 Map:{DAYS=1, HOURS=3, MINUTES=46, SECONDS=40, MILLISECONDS=0, MICROSECONDS=0, NANOSECONDS=0}, 단위를 주문한 상태에서.

해당 맵을 사용자 친화적 인 문자열로 변환하면됩니다.

경고

위의 코드 스 니펫은 두 순간 사이의 간단한 차이를 계산합니다. 설명과 같이 일광 절약 스위치 중에 문제가 발생할 수 있습니다. 이 게시물. 즉, 시간이없는 날짜 간의 차이를 계산하면 하루/시간이 누락 될 수 있습니다.

제 생각에는 날짜 차이는 특히 며칠에 주관적입니다. 당신은 할 수있다:

  • 24 시간 경과 시간 수를 계산 : 날+1- 일 = 1 일 = 24h

  • 일광 절약을 관리하는 경과 시간 수를 계산하십시오 : Day+1 -Day = 1 = 24h (그러나 자정 시간과 일광 절약을 사용하면 0 일과 23 시간이 될 수 있습니다).

  • 수를 계산하십시오 day switches, 이는 하루+1 1pm -Day 11am = 1 일을 의미합니다.

날짜의 정의가 첫 번째 사례와 일치하는 경우 내 대답이 유효합니다.

Jodatime과 함께

Jodatime을 사용하는 경우 : 2 개의 인스턴트 (Millies Backed ReadableInstant)의 Diff를 다음과 같이 얻을 수 있습니다.

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

그러나 지역 날짜/시간에 대한 차이를 얻을 수도 있습니다.

// returns 4 because of the leap year of 366 days
new Period(LocalDate.now(), LocalDate.now().plusDays(365*5), PeriodType.years()).getYears() 

// this time it returns 5
new Period(LocalDate.now(), LocalDate.now().plusDays(365*5+1), PeriodType.years()).getYears() 

// And you can also use these static methods
Years.yearsBetween(LocalDate.now(), LocalDate.now().plusDays(365*5)).getYears()

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

이것은 UTC 날짜와 함께 작동하므로 지역 날짜를 보면 차이가 쉬울 수 있습니다. 그리고 현지 날짜로 올바르게 작동하려면 일광 절약 시간으로 인해 완전히 다른 접근 방식이 필요합니다.

문제를 더 명확하게 정의해야합니다. 너 ~할 수 있었다 둘 사이에 밀리 초만 섭취하십시오 Date 물체와 24 시간 만에 밀리 초 수로 나눕니다.

  • 이것은 시간 영역을 고려하지 않을 것입니다. Date 항상 UTC에 있습니다
  • 이것은 일광 절약 시간을 고려하지 않을 것입니다 (예 : 23 시간 거리에있는 날이있을 수있는 경우).
  • UTC 내에서도 8 월 16 일 오후 11 시부 터 오전 18 시까 지 며칠이 있습니까? 27 시간 밖에 걸리지 않아서 하루는 하루를 의미합니까? 아니면 3 일이어야합니까? 3 일이어야합니까?

사용 Java.Time Java 8+에 내장 된 프레임 워크 :

ZonedDateTime now = ZonedDateTime.now();
ZonedDateTime oldDate = now.minusDays(1).minusMinutes(10);
Duration duration = Duration.between(oldDate, now);
System.out.println("ISO-8601: " + duration);
System.out.println("Minutes: " + duration.toMinutes());

산출:

ISO-8601 : PT24H10M

분 : 1450

자세한 내용은 다음을 참조하십시오 오라클 튜토리얼 그리고 ISO 8601 기준.

tl; dr

쓸모없는 것을 변환하십시오 java.util.Date 교체품에 대한 개체, java.time.Instant. 그런 다음 경과 시간을 a로 계산하십시오 Duration.

Duration d = 
    Duration.between(                   // Calculate the span of time between two moments as a number of hours, minutes, and seconds.
        myJavaUtilDate.toInstant() ,    // Convert legacy class to modern class by calling new method added to the old class.
        Instant.now()                   // Capture the current moment in UTC. About two and a half hours later in this example.
    )
;

D.TOSTRING () : PT2H34M56S

D.Tominutes () : 154

d.tominutespart () : 34

ISO 8601 형식 : PnYnMnDTnHnMnS

현명한 표준 ISO 8601 시간 범위의 간결한 텍스트 표현을 몇 년, 달, 일, 시간 등으로 정의합니다. 표준은 그러한 스팬을 호출합니다. 지속. 형식은입니다 PnYnMnDTnHnMnS 어디에 P "기간"을 의미합니다 T 날짜 부분을 시간 부분과 분리하고 그 사이에는 숫자와 문자가 있습니다.

예 :

  • P3Y6M4DT12H30M5S
    3 년, 6 개월, 4 일, 12 시간, 30 분, 5 초
  • PT4H30M
    4 시간 반

Java.Time

그만큼 Java.Time Java 8에 내장 된 프레임 워크 이후에는 번거로운 오래된 것입니다. java.util.Date/java.util.Calendar 클래스. 새로운 수업은 매우 성공적인 수업에서 영감을 얻었습니다 조다-시간 후임자로 의도 된 프레임 워크, 개념은 비슷하지만 재건 된 프레임 워크. 정의 JSR 310. 연장 Threeten-extra 프로젝트. 참조 지도 시간.

순간

그만큼 Instant 클래스는 타임 라인의 순간을 나타냅니다 UTC 해상도와 함께 나노 초 (최대 9 개) 소수점 분수의 숫자). 

Instant instant = Instant.now() ;  // Capture current moment in UTC.

다음과 같은 레거시 클래스를 피하는 것이 가장 좋습니다 Date/Calendar. 그러나 이전 코드와 상호 작용 해야하는 경우 아직 업데이트되지 않았습니다. Java.Time, 앞뒤로 변환하십시오. 이전 클래스에 추가 된 새로운 전환 방법을 호출하십시오. a java.util.Date an Instant, 전화 Date::toInstant. 

Instant instant = myJavaUtilDate.toInstant() ;  // Convert from legacy `java.util.Date` class to modern `java.time.Instant` class.

시간의 범위

Java.Time 클래스는 시간을 몇 년, 몇 달, 며칠, 시간, 분, 초로 표현한다는이 아이디어를 두 개의 반쪽으로 나누었습니다.

  • Period 몇 년, 몇 달, 며칠 동안
  • Duration 며칠, 시간, 분, 초

여기 예입니다.

ZoneId zoneId = ZoneId.of ( "America/Montreal" );
ZonedDateTime now = ZonedDateTime.now ( zoneId );
ZonedDateTime future = now.plusMinutes ( 63 );
Duration duration = Duration.between ( now , future );

콘솔에 덤프.

둘 다 Period 그리고 Duration 사용 ISO 8601 값의 문자열 표현을 생성하기위한 표준.

System.out.println ( "now: " + now + " to future: " + now + " = " + duration );

지금 : 2015-11-26T00 : 46 : 46 : 48.016-05 : 00 [America/Montreal] to Future : 2015-11-26T00 : 46 : 48.016-05 : 00 [America/Montreal] = pt1h3m

Java 9는 방법을 추가합니다 Duration 일 부분, 시간 부분, 분 부분 및 초 부분을 얻으려면.

전체 기간 동안 총 일 또는 시간 또는 몇 분 또는 몇 초 또는 밀리 초 또는 나노초를 얻을 수 있습니다.

long totalHours = duration.toHours();

Java 9에서 Duration 클래스는 새로운 방법을 얻습니다 며칠, 시간, 분, 초, 밀리 초/나노초의 다양한 부분을 반환합니다. 를 불러 to…Part 행동 양식: toDaysPart(), toHoursPart(), 등등.

ChronoUnit

“경과 한 일수”와 같이 더 간단한 더 큰 세분화에 관심이 있다면 ChronoUnit 열거적.

long daysElapsed = ChronoUnit.DAYS.between( earlier , later );

또 다른 예.

Instant now = Instant.now();
Instant later = now.plus( Duration.ofHours( 2 ) );
…
long minutesElapsed = ChronoUnit.MINUTES.between( now , later );

120

Java.Time에 대해

그만큼 Java.Time 프레임 워크는 Java 8 이상에 내장되어 있습니다. 이 수업은 번거로운 오래된 것을 대체합니다 유산 다음과 같은 날짜 시간 수업 java.util.Date, Calendar, & SimpleDateFormat.

그만큼 조다-시간 지금 프로젝트 유지 관리 모드, Java.Time으로의 마이그레이션을 조언합니다.

자세한 내용은 오라클 튜토리얼. 많은 예와 설명에 대한 검색 스택 오버 플로우. 사양입니다 JSR 310.

Java.Time 수업을 어디에서 얻을 수 있습니까?

그만큼 Threeten-extra 프로젝트는 추가 클래스로 Java.Time을 연장합니다. 이 프로젝트는 Java.Time에 향후 추가 할 수있는 근거입니다. 여기에서 유용한 수업을 찾을 수 있습니다 Interval, YearWeek, YearQuarter, 그리고 더.

조다-시간

업데이트 : 조다-시간 이제 프로젝트가 시작되었습니다 유지 관리 모드, 팀이 Java.Time 클래스. 나는이 섹션을 역사에 그대로 둔다.

Joda-Time 라이브러리는 기본값에 ISO 8601을 사용합니다. 그것의 Period 클래스 PNYNMNDTNHNMNS 문자열을 구문 분석하고 생성합니다.

DateTime now = DateTime.now(); // Caveat: Ignoring the important issue of time zones.
Period period = new Period( now, now.plusHours( 4 ).plusMinutes( 30));
System.out.println( "period: " + period );

렌더 :

period: PT4H30M

Days d = Days.daysBetween(startDate, endDate);
int days = d.getDays();

https://www.joda.org/joda-time/faq.html#datediff

약간 간단한 대안 : 

System.currentTimeMillis() - oldDate.getTime()

"더 좋은"것에 관해서는 : 글쎄, 정확히 무엇이 필요합니까? 시간 지속 시간을 여러 시간과 일 등으로 표현하는 문제는 날짜의 복잡성으로 인한 부정확성과 잘못된 기대로 이어질 수 있다는 것입니다 (예 : 일광 절약 시간으로 인해 23 ~ 25 시간이있을 수 있음).

밀리 초 접근법을 사용하면 일부 지역에서 문제가 발생할 수 있습니다.

예를 들어, 두 날짜 03/24/2007과 03/25/25/25/25/25/25의 차이는 1 일이어야합니다.

그러나 밀리 초 경로를 사용하면 영국에서 실행하면 0 일이 걸립니다! 

/** Manual Method - YIELDS INCORRECT RESULTS - DO NOT USE**/  
/* This method is used to find the no of days between the given dates */  
public long calculateDays(Date dateEarly, Date dateLater) {  
   return (dateLater.getTime() - dateEarly.getTime()) / (24 * 60 * 60 * 1000);  
}

이를 구현하는 더 좋은 방법은 java.util.calendar를 사용하는 것입니다

/** Using Calendar - THE CORRECT WAY**/  
public static long daysBetween(Calendar startDate, Calendar endDate) {  
  Calendar date = (Calendar) startDate.clone();  
  long daysBetween = 0;  
  while (date.before(endDate)) {  
    date.add(Calendar.DAY_OF_MONTH, 1);  
    daysBetween++;  
  }  
  return daysBetween;  
}

날짜와 시간의 차이점을 찾을 수있는 방법에는 여러 가지가 있습니다. 내가 아는 가장 간단한 방법 중 하나는 다음과 같습니다.

      Calendar calendar1 = Calendar.getInstance();
      Calendar calendar2 = Calendar.getInstance();
      calendar1.set(2012, 04, 02);
      calendar2.set(2012, 04, 04);
      long milsecs1= calendar1.getTimeInMillis();
      long milsecs2 = calendar2.getTimeInMillis();
      long diff = milsecs2 - milsecs1;
      long dsecs = diff / 1000;
      long dminutes = diff / (60 * 1000);
      long dhours = diff / (60 * 60 * 1000);
      long ddays = diff / (24 * 60 * 60 * 1000);

      System.out.println("Your Day Difference="+ddays);

인쇄 문은 예제 일뿐입니다. 원하는 방식으로 포맷 할 수 있습니다.

여기의 모든 답변은 정확하지만 레거시 Java 또는 Joda 또는 이와 같은 타사 Libs를 사용하기 때문에 새로 사용하여 다른 방법을 떨어 뜨릴 것입니다. Java.Time Java 8 이상의 수업. 보다 오라클 튜토리얼.

사용 LocalDate 그리고 ChronoUnit:

LocalDate d1 = LocalDate.of(2017, 5, 1);
LocalDate d2 = LocalDate.of(2017, 5, 18);

long days = ChronoUnit.DAYS.between(d1, d2);
System.out.println( days );

밀리 초에서 날짜를 빼면 (다른 게시물에 설명 된대로) 가지다 날짜의 시간 부분을 지울 때 시간이 아닌 Hour_of_day를 사용하려면 :

public static final long MSPERDAY = 60 * 60 * 24 * 1000;
...
final Calendar dateStartCal = Calendar.getInstance();
dateStartCal.setTime(dateStart);
dateStartCal.set(Calendar.HOUR_OF_DAY, 0); // Crucial.
dateStartCal.set(Calendar.MINUTE, 0);
dateStartCal.set(Calendar.SECOND, 0);
dateStartCal.set(Calendar.MILLISECOND, 0);
final Calendar dateEndCal = Calendar.getInstance();
dateEndCal.setTime(dateEnd);
dateEndCal.set(Calendar.HOUR_OF_DAY, 0); // Crucial.
dateEndCal.set(Calendar.MINUTE, 0);
dateEndCal.set(Calendar.SECOND, 0);
dateEndCal.set(Calendar.MILLISECOND, 0);
final long dateDifferenceInDays = ( dateStartCal.getTimeInMillis()
                                  - dateEndCal.getTimeInMillis()
                                  ) / MSPERDAY;
if (dateDifferenceInDays > 15) {
    // Do something if difference > 15 days
}

당신이 사용하고 싶지 않 JodaTime 또는 이와 유사한 최고의 솔루션입니다 아마 이:

final static long MILLIS_PER_DAY = 24 * 3600 * 1000;
long msDiff= date1.getTime() - date2.getTime();
long daysDiff = Math.round(msDiff / ((double)MILLIS_PER_DAY));

수 ms 하루는 항상 동일하지 않습니다(때문에 일광 절약 시간과 윤초)지만,그것은 매우 가까운,그리고 적어도 편차로 인해 일광 절약 시간제 취소 통해 더 긴 기간입니다.그러므로 나누고 그림을 줄 것이 올바른 결과(적어도 한 현지 일정에 사용되는 포함하지 않는 이상한 시간이 점프 이외의 다른 DST 및 윤 초)입니다.

참고로 이것은 여전히정 date1 고 date2 은 설정을 하루 중 같은 시간.을 위한 다른 시간의 하루,당신이 첫 번째가 무엇을 정의하는 날짜"차이"를 의미하는 것으로 지적 존 스키트.

보세요 조다 시간, 이것은 Java의 개선 된 날짜/시간 API이며 Scala에서 잘 작동해야합니다.

Joda 간격과 날의 차이를 보여 드리겠습니다.

DateTime start = new DateTime(2012, 2, 6, 10, 44, 51, 0);
DateTime end = new DateTime(2012, 2, 6, 11, 39, 47, 1);
Interval interval = new Interval(start, end);
Period period = interval.toPeriod();
System.out.println(period.getYears() + " years, " + period.getMonths() + " months, " + period.getWeeks() + " weeks, " + period.getDays() + " days");
System.out.println(period.getHours() + " hours, " + period.getMinutes() + " minutes, " + period.getSeconds() + " seconds ");
//Result is:
//0 years, 0 months, *1 weeks, 1 days*
//0 hours, 54 minutes, 56 seconds 

//Period can set PeriodType,such as PeriodType.yearMonthDay(),PeriodType.yearDayTime()...
Period p = new Period(start, end, PeriodType.yearMonthDayTime());
System.out.println(p.getYears() + " years, " + p.getMonths() + " months, " + p.getWeeks() + " weeks, " + p.getDays() + "days");
System.out.println(p.getHours() + " hours, " + p.getMinutes() + " minutes, " + p.getSeconds() + " seconds ");
//Result is:
//0 years, 0 months, *0 weeks, 8 days*
//0 hours, 54 minutes, 56 seconds

"2 일 03H 42M 07S"와 같은 형식의 반환 문자열이 필요한 경우 다음을 시도하십시오.

public String fill2(int value)
{
    String ret = String.valueOf(value);

    if (ret.length() < 2)
        ret = "0" + ret;            
    return ret;
}

public String get_duration(Date date1, Date date2)
{                   
    TimeUnit timeUnit = TimeUnit.SECONDS;

    long diffInMilli = date2.getTime() - date1.getTime();
    long s = timeUnit.convert(diffInMilli, TimeUnit.MILLISECONDS);

    long days = s / (24 * 60 * 60);
    long rest = s - (days * 24 * 60 * 60);
    long hrs = rest / (60 * 60);
    long rest1 = rest - (hrs * 60 * 60);
    long min = rest1 / 60;      
    long sec = s % 60;

    String dates = "";
    if (days > 0) dates = days + " Days ";

    dates += fill2((int) hrs) + "h ";
    dates += fill2((int) min) + "m ";
    dates += fill2((int) sec) + "s ";

    return dates;
}

여기에서 예제를 확인하십시오 http://www.roseindia.net/java/beginners/datedifferent.shtml이 예는 날, 시간, 분, SECS 및 Milli SEC의 차이를 제공합니다 :).

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

public class DateDifferent {
    public static void main(String[] args) {
        Date date1 = new Date(2009, 01, 10);
        Date date2 = new Date(2009, 07, 01);
        Calendar calendar1 = Calendar.getInstance();
        Calendar calendar2 = Calendar.getInstance();
        calendar1.setTime(date1);
        calendar2.setTime(date2);
        long milliseconds1 = calendar1.getTimeInMillis();
        long milliseconds2 = calendar2.getTimeInMillis();
        long diff = milliseconds2 - milliseconds1;
        long diffSeconds = diff / 1000;
        long diffMinutes = diff / (60 * 1000);
        long diffHours = diff / (60 * 60 * 1000);
        long diffDays = diff / (24 * 60 * 60 * 1000);
        System.out.println("\nThe Date Different Example");
        System.out.println("Time in milliseconds: " + diff + " milliseconds.");
        System.out.println("Time in seconds: " + diffSeconds + " seconds.");
        System.out.println("Time in minutes: " + diffMinutes + " minutes.");
        System.out.println("Time in hours: " + diffHours + " hours.");
        System.out.println("Time in days: " + diffDays + " days.");
    }
}

GMT 시간대를 사용하여 캘린더 인스턴스를 얻고 세트 캘린더 클래스의 세트 방법을 사용하여 시간을 설정하십시오. GMT 타임 존에는 0 오프셋 (실제로 중요하지 않음)과 일광 절약 시간 플래그가 False로 설정되어 있습니다.

    final Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));

    cal.set(Calendar.YEAR, 2011);
    cal.set(Calendar.MONTH, 9);
    cal.set(Calendar.DAY_OF_MONTH, 29);
    cal.set(Calendar.HOUR, 0);
    cal.set(Calendar.MINUTE, 0);
    cal.set(Calendar.SECOND, 0);
    final Date startDate = cal.getTime();

    cal.set(Calendar.YEAR, 2011);
    cal.set(Calendar.MONTH, 12);
    cal.set(Calendar.DAY_OF_MONTH, 21);
    cal.set(Calendar.HOUR, 0);
    cal.set(Calendar.MINUTE, 0);
    cal.set(Calendar.SECOND, 0);
    final Date endDate = cal.getTime();

    System.out.println((endDate.getTime() - startDate.getTime()) % (1000l * 60l * 60l * 24l));

다음 코드는 원하는 출력을 제공 할 수 있습니다.

String startDate = "Jan 01 2015";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMM dd yyyy");
LocalDate date = LocalDate.parse(startDate, formatter);

String currentDate = "Feb 11 2015";
LocalDate date1 = LocalDate.parse(currentDate, formatter);

System.out.println(date1.toEpochDay() - date.toEpochDay());

public static String getDifferenceBtwTime(Date dateTime) {

    long timeDifferenceMilliseconds = new Date().getTime() - dateTime.getTime();
    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 = (long)(timeDifferenceMilliseconds / (1000 * 60 * 60 * 24 * 365));

    if (diffSeconds < 1) {
        return "one sec ago";
    } else if (diffMinutes < 1) {
        return diffSeconds + " seconds ago";
    } else if (diffHours < 1) {
        return diffMinutes + " minutes ago";
    } else if (diffDays < 1) {
        return diffHours + " hours ago";
    } else if (diffWeeks < 1) {
        return diffDays + " days ago";
    } else if (diffMonths < 1) {
        return diffWeeks + " weeks ago";
    } else if (diffYears < 12) {
        return diffMonths + " months ago";
    } else {
        return diffYears + " years ago";
    }
}

참고 : STARTDATE 및 ENDDATES는 -> java.util.date입니다 

import org.joda.time.Duration;
import org.joda.time.Interval;
// Use .getTime() unless it is a joda DateTime object
Interval interval = new Interval(startDate.getTime(), endDate.getTime());
Duration period = interval.toDuration();
//gives the number of days elapsed between start 
period.getStandardDays();

그리고 종료 날짜

며칠과 비슷하게 몇 시간, 몇 초, 몇 초를 얻을 수도 있습니다.

period.getStandardHours();
period.getStandardMinutes();
period.getStandardSeconds();

int daysDiff = (date1.getTime() - date2.getTime()) / MILLIS_PER_DAY;

가장 좋은 일은입니다

(Date1-Date2)/86 400 000

그 숫자는 수입니다 밀리 초 하루에.

한 번의 데이트 날짜는 밀리 초의 차이를 제공합니다.

답을 수집하십시오 더블 변하기 쉬운.

아마도 그것은 아마도 가장 간단한 방법 일 것입니다. 아마도 내가 Java로 코딩하고 있었기 때문일 것입니다.

결과가 밀리 초로 반환되는 것에 만족하십니까, 아니면 다른 형식으로 반환하는 것을 선호하는 질문의 일부입니까?

표준 API를 사용하지 않음. 당신은 다음과 같은 일을 할 수 있습니다.

class Duration {
    private final TimeUnit unit;
    private final long length;
    // ...
}

또는 사용할 수 있습니다 조다:

DateTime a = ..., b = ...;
Duration d = new Duration(a, b);

초기 질문에 답하기 위해 :

Long Getage () {}와 같은 함수에 다음 코드를 넣으십시오.

Date dahora = new Date();
long MillisToYearsByDiv = 1000l *60l * 60l * 24l * 365l;
long javaOffsetInMillis = 1990l * MillisToYearsByDiv;
long realNowInMillis = dahora.getTime() + javaOffsetInMillis;
long realBirthDayInMillis = this.getFechaNac().getTime() + javaOffsetInMillis;
long ageInMillis = realNowInMillis - realBirthDayInMillis;

return ageInMillis / MillisToYearsByDiv;

여기서 가장 중요한 것은 곱하고 나누는 경우 긴 숫자로 작업하는 것입니다. 물론, Java가 날짜의 미적분에 적용되는 오프셋.

:)

질문에는 Scala가 태그되어 있으므로

import scala.concurrent.duration._
val diff = (System.currentTimeMillis() - oldDate.getTime).milliseconds
val diffSeconds = diff.toSeconds
val diffMinutes = diff.toMinutes
val diffHours = diff.toHours
val diffDays = diff.toDays

다음은 종속성이없는 O (1)의 올바른 Java 7 솔루션입니다.

public static int countDaysBetween(Date date1, Date date2) {

    Calendar c1 = removeTime(from(date1));
    Calendar c2 = removeTime(from(date2));

    if (c1.get(YEAR) == c2.get(YEAR)) {

        return Math.abs(c1.get(DAY_OF_YEAR) - c2.get(DAY_OF_YEAR)) + 1;
    }
    // ensure c1 <= c2
    if (c1.get(YEAR) > c2.get(YEAR)) {
        Calendar c = c1;
        c1 = c2;
        c2 = c;
    }
    int y1 = c1.get(YEAR);
    int y2 = c2.get(YEAR);
    int d1 = c1.get(DAY_OF_YEAR);
    int d2 = c2.get(DAY_OF_YEAR);

    return d2 + ((y2 - y1) * 365) - d1 + countLeapYearsBetween(y1, y2) + 1;
}

private static int countLeapYearsBetween(int y1, int y2) {

    if (y1 < 1 || y2 < 1) {
        throw new IllegalArgumentException("Year must be > 0.");
    }
    // ensure y1 <= y2
    if (y1 > y2) {
        int i = y1;
        y1 = y2;
        y2 = i;
    }

    int diff = 0;

    int firstDivisibleBy4 = y1;
    if (firstDivisibleBy4 % 4 != 0) {
        firstDivisibleBy4 += 4 - (y1 % 4);
    }
    diff = y2 - firstDivisibleBy4 - 1;
    int divisibleBy4 = diff < 0 ? 0 : diff / 4 + 1;

    int firstDivisibleBy100 = y1;
    if (firstDivisibleBy100 % 100 != 0) {
        firstDivisibleBy100 += 100 - (firstDivisibleBy100 % 100);
    }
    diff = y2 - firstDivisibleBy100 - 1;
    int divisibleBy100 = diff < 0 ? 0 : diff / 100 + 1;

    int firstDivisibleBy400 = y1;
    if (firstDivisibleBy400 % 400 != 0) {
        firstDivisibleBy400 += 400 - (y1 % 400);
    }
    diff = y2 - firstDivisibleBy400 - 1;
    int divisibleBy400 = diff < 0 ? 0 : diff / 400 + 1;

    return divisibleBy4 - divisibleBy100 + divisibleBy400;
}


public static Calendar from(Date date) {

    Calendar c = Calendar.getInstance();
    c.setTime(date);

    return c;
}


public static Calendar removeTime(Calendar c) {

    c.set(HOUR_OF_DAY, 0);
    c.set(MINUTE, 0);
    c.set(SECOND, 0);
    c.set(MILLISECOND, 0);

    return c;
}

다른 모든 답변을 통해 넘어간 후 Java 7 날짜 유형을 유지하지만 Java 8 Diff 접근 방식으로보다 정확/표준을 유지하십시오.

public static long daysBetweenDates(Date d1, Date d2) {
    Instant instant1 = d1.toInstant();
    Instant instant2 = d2.toInstant();
    long diff = ChronoUnit.DAYS.between(instant1, instant2);
    return diff;
}

이 시도: 

int epoch = (int) (new java.text.SimpleDateFormat("MM/dd/yyyy HH:mm:ss").parse("01/01/1970  00:00:00").getTime() / 1000);

Parse () 메소드 파라에서 문자열을 편집 할 수 있습니다.

라이센스 : CC-BY-SA ~와 함께 속성
제휴하지 않습니다 StackOverflow
scroll top