java.util.DateScala에서 Java 클래스를 사용 하고 있으며 Date객체와 현재 시간 을 비교하고 싶습니다 . getTime ()을 사용하여 델타를 계산할 수 있다는 것을 알고 있습니다.

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

그러나 이것은 단지 long밀리 초를 나타냅니다. 시간 델타를 얻는 더 간단하고 좋은 방법이 있습니까?

JDK DateAPI는 불행히도 크게 망가졌습니다. Joda Time 라이브러리를 사용하는 것이 좋습니다 .

Joda Time에는 시간 간격 개념이 있습니다 .

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

편집 : 그런데, Joda는 두 Interval시간 순간 사이의 시간 간격을 나타내는 개념 (8am과 10am 사이 Duration의 시간을 나타냄 )과 실제 시간 경계가없는 시간을 나타내는 것 (예 : 2 시간을 나타냄)이라는 두 가지 개념을 가지고 있습니다.

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

간단한 diff (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);

두 날짜의 차이를 분 단위로 가져옵니다.

TimeUnit는 java.util.concurrent.TimeUnit나노에서 며칠로가는 표준 Java 열거 형입니다.

사람이 읽을 수있는 diff (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 시간 경과 시간 계산 : day + 1-day = 1 day = 24h

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

• 수 집계 day switches(: P 일광 절약이있는 경우 또는 1H), 경과 시간은 단지 2H 경우에도, 일 오전 11 = 1 일 - + 1 일 오후 1시 수단

일의 날짜 차이 정의가 첫 번째 사례와 일치하면 내 답변이 유효합니다.

JodaTime으로

JodaTime을 사용하는 경우 다음을 사용하여 2 개의 인스턴트 (millies 백업 ReadableInstant) 날짜에 대한 차이를 얻을 수 있습니다.

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 날짜와 함께 작동하므로 현지 날짜를 보면 차이가 날 수 있습니다. 현지 날짜와 올바르게 작동하려면 일광 절약 시간으로 인해 완전히 다른 방법이 필요합니다.

Java 8 이상에 내장 된 java.time 프레임 워크 사용 :

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

자세한 내용은 Oracle Tutorial 및 ISO 8601 표준을 참조하십시오 .

문제를보다 명확하게 정의해야합니다. 당신은 할 수 단지 둘 사이의 밀리 초 단위로 가지고 Date예를 들어, 24 시간을 밀리 초 단위로 개체와 나누기 :하지만 ...

• 시간대를 고려하지 않습니다- Date항상 UTC
• 일광 절약 시간을 고려하지 않습니다 (예를 들어 23 시간 밖에 걸리지 않는 날이있을 수 있음)
• UTC 내에서도 8 월 16 일 오후 11 시부 터 8 월 18 일 오전 2 시까 지 며칠이 있습니까? 27 시간 밖에 안 남았나요? 아니면 3 개의 날짜를 다루므로 3 일이되어야합니까?

tl; dr

사용하지 않는 java.util.Date개체를 대체물로 변환하십시오 java.time.Instant. 그런 다음 경과 시간을로 계산하십시오 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를 Where P수단 "기간"은이 T시간 부분의 일 부분을 분리하고, 다음에 문자 숫자 사이.

예 :

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

java.time

Java 8 이상에 내장 된 java.time 프레임 워크는 번거로운 이전 java.util.Date/ java.util.Calendar클래스를 대체합니다 . 새로운 클래스는 개념적으로 유사하지만 재구성 된 후계자로 의도 된 매우 성공적인 Joda-Time 프레임 워크에서 영감을 얻었습니다 . JSR 310에 의해 정의됩니다 . ThreeTen-Extra 프로젝트로 확장되었습니다 . 학습서를 참조하십시오 .

순간

이 Instant클래스는 나노초 의 해상도 (소수점의 최대 9 자리)로 UTC 의 타임 라인에서 순간을 나타냅니다 .

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

Date/ 와 같은 레거시 클래스를 피하는 것이 가장 Calendar좋습니다. 그러나 아직 java.time으로 업데이트되지 않은 이전 코드와 상호 운용해야하는 경우 앞뒤로 변환하십시오. 이전 클래스에 추가 된 새 변환 메소드를 호출하십시오. 에서로 이동 java.util.Date하려면을 (를 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 의 가치의 String 표현을 생성하기위한 표준.

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

지금 : 2015-11-26T00 : 46 : 48.016-05 : 00 [미국 / 몬트리올]에서 미래로 : 2015-11-26T00 : 46 : 48.016-05 : 00 [미국 / 몬트리올] = 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의 프레임 워크는 나중에 자바 8에 내장되어 있습니다. 이 클래스는 까다로운 기존에 대신 기존 과 같은 날짜 - 시간의 수업을 java.util.Date, Calendar, SimpleDateFormat.

Joda 타임 프로젝트는 현재의 유지 관리 모드 , java.time로 마이그레이션을 조언한다.

자세한 내용은 Oracle Tutorial을 참조하십시오 . 많은 예제와 설명을 보려면 스택 오버플로를 검색하십시오. 사양은 JSR 310 입니다.

java.time 클래스는 어디서 구할 수 있습니까?

• 자바 SE 8 및 SE 9 이상
  • 내장.
  • 번들로 구현 된 표준 Java API의 일부입니다.
  • Java 9에는 몇 가지 사소한 기능과 수정 사항이 추가되었습니다.
• Java SE 6 및 SE 7
  • 대부분의 java.time 기능은 ThreeTen-Backport의 Java 6 & 7로 백 포트됩니다 .
• 기계적 인조 인간
  • ThreeTenABP의 프로젝트 적응 ThreeTen - 백 포트 특히 안드로이드에 대한 (위에서 언급).
  • 사용 방법…을 참조하십시오 .

ThreeTen - 추가 프로젝트 추가 클래스와 java.time를 확장합니다. 이 프로젝트는 향후 java.time에 추가 될 수있는 입증 된 근거입니다. 당신은 여기에 몇 가지 유용한 클래스와 같은 찾을 수 있습니다 Interval, YearWeek, YearQuarter, 그리고 더 .

조다 타임

업데이트 : Joda-Time 프로젝트는 이제 유지 관리 모드 에 있으며 팀은 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()

"nicer"는 정확히 무엇을 필요로합니까? 기간을 여러 시간 및 일 등으로 나타내는 데 따른 문제점은 날짜의 복잡성으로 인해 부정확하고 잘못된 기대로 이어질 수 있다는 것입니다 (예 : 일광 절약 시간으로 인해 23 일 또는 25 시간이 소요될 수 있음).

밀리 초 방식을 사용하면 일부 로케일에서 문제가 발생할 수 있습니다.

예를 들어, 2007 년 3 월 24 일과 2007 년 3 월 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);

print 문은 단지 예일뿐입니다. 원하는 방식으로 형식을 지정할 수 있습니다.

여기에있는 모든 대답은 정확하지만 joda 또는 이와 유사한 레거시 Java 또는 타사 라이브러리를 사용 하므로 Java 8 이상에서 새로운 java.time 클래스를 사용하여 다른 방법을 사용하지 않을 것 입니다. 오라클 튜토리얼 참조 .

사용 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하지 HOUR을 사용 :

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하루 중 같은 시간으로 설정됩니다. Jon Skeet이 지적한대로 하루 중 다른 시간에 대해 먼저 "날짜 차이"의 의미를 정의해야합니다.

개선 된 Java 용 Date / Time API 인 Joda Time을 살펴보고 Scala와 잘 작동합니다.

Joda Interval과 Days의 차이점을 보여 드리겠습니다.

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

참고 : 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();

여기 예를 확인하십시오 http://www.roseindia.net/java/beginners/DateDifferent.shtml 이 예는 일,시, 분, 초 및 밀리 초의 차이를 보여줍니다. :).

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 시간대를 사용하여 캘린더의 인스턴스를 가져오고 Calendar 클래스의 set 메소드를 사용하여 시간을 설정하십시오. 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";
    }
}   

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

가장 좋은 것은

(Date1-Date2)/86 400 000 

이 숫자는 하루 의 밀리 초 수 입니다.

하나의 날짜와 다른 날짜는 밀리 초 단위의 차이를 제공합니다.

이중 변수로 답을 수집하십시오 .

다음은 종속성이없는 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;
}

아마도 가장 간단한 방법 일 것입니다. 아마도 내가 자바로 코딩 했으므로 (아마도 날짜와 시간 라이브러리가 있음) 아마도 그 코드가 나에게 "단순하고 멋지게 보입니다"!

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

표준 API를 사용하지 않습니다. 다음과 같은 작업을 수행 할 수 있습니다.

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

또는 Joda 를 사용할 수 있습니다 .

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가 적용되는 오프셋.

:)

질문에 스칼라 태그가 붙어 있기 때문에

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

다른 모든 답변을 넘어 서면 Java 7 Date 유형을 유지하지만 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 () 메소드 param에서 문자열을 편집 할 수 있습니다.