Programing

2자바 날짜 인스턴스의 차이를 계산 중입니다

c10106 2022. 5. 17. 22:32

2자바 날짜 인스턴스의 차이를 계산 중입니다

나는 자바나는 자바를을 사용하고 있습니다 사용하고 있습니다java.util.Date스칼라에서 등급과스칼라에서 등급과 a비교하려면을 비교 하려고 합니다.Date개체 및 현재 시간.개체및 현재 시간.나는 getTime():나는 getTime()을사용하여델타를 계산할 수있을 거요를 사용하여 델타를 계산할 수 있을 거요:.

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

그러나, 이 일은나를 진퇴 a론 그러나,이 일은요.long밀리초를 나타내는입니다.밀리초를 나타내는입니다.그곳은 간단하고 더 나은 방법은 시간 델타를 했나?그곳은 간단하고 더 나은 방법은 시간델타를 했나?

간단한 연락(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날짜가 연락을 가져오려면.

TimeUnit있이다java.util.concurrent.TimeUnit, 표준 자바 enum nanos days.에 입국자반 열거형 nanos 표준 요즘갈 예정

인간의 읽기 쉬운 연락(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}과 함께 유닛을 주문하다.과함께 유닛을 주문하다.

당신은 그냥 하나의 사용자 친화적 문자열로 그 지도에 변환하고 있다.

경고

위의 코드 단편 2아주 단순 연락 compute.같은 이 자리에 설명되어 그것은 일광 절약 스위치에 문제를 일으킬 수 있다당신이 이 날짜들 사이의 즐길 시간은 연락 compute 당신은 실종된 day/hour한 셈이다.

내 생각에 주관적 요 며칠간 특히 날짜 연락은당신은:

24h 경과 시간:day+1-날)을 헤아리다 1날 24h 일고 있다.
, 일광 절약을 돌보:day+1-=1=24h( 하지만을 사용하여 자정 시간과 일광 절약 될 수 있0낮과 23h)경과 시간의 개수를 세어 보라.
카운트 의 숫자를 세다의 수day switches, day+1 의미한다 오후 1시-날 오전 11시=1날 비록 이 경과 시간은 단지 secundahora2시간마다.(또는 1h이 있으면 일광 절약:p),day+1 의미한다 비록이경과시간은단지 secundahora2시간마다.(또는 1h이 있으면일광 절약:p)1시-날 오전 11시=1날 오후.

만약 날짜 연락의 날에 당신의 정의 1사건과 일치하는 나의 대답은 유효합니다.

JodaTime으로

만약 당신이 JodaTime을 쓰고 2아주 옛날의 연락을 받을 수 있(millies을 것처럼 보인다.)인스턴트로 거슬러 올라간다:

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

하지만 너는 또 국내 dates/times을 위한 연락을 받을 수 있다.

// 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()

이 자바 개발 키트 자바 개발 키트DateAPI가 불행히도 형편없이 망가졌다.나는 Joda Time 라이브러리를 사용하는 것을 추천한다.

Joda Time은 시간 간격의 개념을 가지고 있다.

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

편집:그런데 Joda한 두가지 개념:편집:그런데, 조다는 두 가지 개념을 가지고 있닸다.Interval시간의 두번에 아주 사이의 거리.(오전과 10시부터 오후 사이에 시간을 나타내는), 두 시간을 대표하는 동안시간 간격(오전 8시에서 10시 사이)싱크 a사이의 인스턴스Duration그 경계(e.g. 두시간을 나타내!)실제 시간도 없이 시간의 길이를 반영합니다.실제 시간 경계가 없는 시간 길이를 나타낸다(예:2시간 표시).

만약 시간만 comparisions에 대해 보살핌으로, 대부분의비교만신경 쓴다면 대부분 시간.Date구현 도구 구현(자바 개발 키트 1포함)구현(는 자바 개발 키트를 포함하여).Comparable를 사용할 수 있는 인터페이스

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 자습서 및 ISO 8601 표준을 참조하십시오.

한줄 요약

당신의 구식사용하지 않는 변환으로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.to Minutes(): 154

d.to MinutesPart(): 34

ISO8601형식:ISO8601형식:`PnYnMnDTnHnMnS`

합리적인 표준 ISO 8601은 시간 범위의 간결한 텍스트 표현을 년, 월, 일, 시간 등으로 정의한다.표준은 그러한 기간을 지속시간이라고 부른다.형식은PnYnMnDTnHnMnS에 있어서P"주기"를 의미하며,T날짜 부분과 시간 부분을 구분하고, 그 중간에는 문자가 뒤따르는 숫자가 있다.

예:

P3Y6M4DT12H30M5S
PT4H30M
반

자바.시간

Java 8에 내장된 Java.time 프레임워크는 나중에 골치 아픈 오래된 것을 대체한다.java.util.Date/java.util.Calendar반새로운 계층은 그 후계자로 의도된 매우 성공적인 Joda-Time 프레임워크에서 영감을 얻었으며, 개념은 유사하지만 재설계되었다.JSR 310에 의해 정의된다.ThreeTen-Extra 프로젝트에 의해 확장됨.자습서를 참조하십시오.

모멘트

클래스는 시간 표시 막대의 한 순간을 UTC로 나타내며, 분해능은 소수점 이하 9자리까지입니다.

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

같은 유산 수업을 피하기 위해 적합합니다.Date/Calendar. 하지만 그렇게 해야 한다면 inter-operate과 코드가 아직 업데이트될 java.time, 변환하고 있습니다.새로운 변환 방법은 오래 된 수업에 추가됩니다.한 java.util에서 이동하면.날짠 인스턴트라고 부르는 날짜에::toInstant.

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

시간의 무엇일까

그 java.time 수업:몇년, 월, 일, 시간, 분, 두반 뇌는 몇초 안에 숫자로 시간의 한뼘을 대표하는 이 아이디어 똑같이 나누어 왔다.

연도, 월 기간, 수일
일수, 시간, 분, 초에 기간.

여기 예가 있다.

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 );

now: 2015-11-26T00:46:48.016-05:00[America/Montreal] ~ 미래: 2015-11-26T00:46:48.016-05:00[미국/몬트리얼] = PT1H3M

자바 9자바 9는 메소드를 수 있는 방안을 추가한다.Duration낮 부분을 얻기 위해,시간 부분, minutes 부분, 초의 부분이다.요일 부분,시간 부분,분 단위,초 단위.

전체 Duration에서 총 일 수, 시간, 분 또는 초, 밀리초 또는 나노초를 얻을 수 있다.

long totalHours = duration.toHours();

Java 9에서 클래스는 일, 시간, 분, 초, 밀리초/나노초의 다양한 부분을 반환하는 새로운 방법을 얻는다.콜 더to…Part방법:방법:toDaysPart()toHoursPart()그리고 기타 등등., 등등.

`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 이상에 내장되어 있다.이러한 수업은 , , & 같은 골치 아픈 오래된 레거시 날짜-시간 수업을 대체한다.

현재 유지보수 모드에 있는 Joda-Time 프로젝트는 Java.time으로의 마이그레이션을 권고한다.

자세한 내용은 Oracle 자습서를 참조하십시오.그리고 스택 오버플로를 검색하여 많은 예와 설명을 참조하십시오.사양은 JSR 310이다.

Java.time 클래스를 가져올 위치

Java SE 8 및 SE 9 이상
- 붙박이
- 번들 구현이 포함된 표준 Java API의 일부.
- Java 9는 몇 가지 사소한 기능과 수정 사항을 추가했다.
Java SE 6 및 SE 7
- 대부분의 Java.time 기능은 ThreeTen-Backport에서 Java 6 & 7로 역포팅된다.
안드로이드
- ThreeTen동맥 혈압 프로젝트는 특별히 Android용 ThreeTen-Backport (위에서 언급함)를 채택하고 있다.
- 사용 방법을 참조하십시오.

ThreeTen-Extra 프로젝트는 추가 클래스와 함께 java.time을 확장한다.이 프로젝트는 Java.time에 향후 추가될 가능성이 있는 입증의 장이다.당신은 여기서 , , , , 그리고 그 이상과 같은 몇 가지 유용한 수업들을 찾을 수 있을 것이다.

조다 타임

UPDATE: Joda-Time 프로젝트는 현재 유지 보수 모드에 있으며, 팀은 Java.Time 클래스로 마이그레이션을 권고한다.나는 이 부분을 역사를 위해 그대로 둔다.

그 Joda-Time 도서관이 현재의 기본 값을 ISO8601를 사용한다.Joda-Time 라이브러리는 기본값으로 ISO8601을 사용한다.그것의 그것들Period등급 parses고 이 PnYnMnDTnHnMnS 문자열 생성합니다.등급 parses고 이 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 );

Renders:

period: PT4H30M

당신은 더 명확하게 당신의 문제 규정할 필요가 있다.그냥 그 둘 사이에는 밀리초 단위의 수가 걸릴 수 있다.Date밀리초의 24시간 안에 수가 예를 들어 개체는, 나누기,...밀리초의 24시간 안에수가예를 들어 개체는, 나누기,... 하지만:하지만:

이 고려 사항-이 고려 사항으로-시간대 걸리지 않을 거예요에 시간대 걸리지 않을 거예요.Date항상 UTC항상 협정 세계시에 있에 있
이 고려 사항은(예를 들어 겨우 23시간 동안 어디에 살 날,)에 시간을 절약할 일광 걸리지 않을 거예요.
CoordinatedUniversalTime에서조차, 몇일 동안 거기에 8월 16일에 오후 11시 8월 18일부터 새벽 2시나 되죠?그것은 27시간, 이렇게 어느 날을 의미합니까?아니면 그래야 할 것 3일 간 3일정해?

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일 시간을 가질 수 있)의 복잡성 때문에 초래할 수 있다.

MS접근법의 사용은 어떤 지역에서는 문제를 일으킬 수 있다

우리는 예를 들어, 그 두 날짜 03/24/2007과 03/25/2007의 차이를 1날;.

영국에서 이 실행 하지만 MS경로를 이용하여, 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을 사용하는 것입니다.달력

/** 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);

인쇄 성명은 단지 하나의 예시-, 너가 좋아하는 식으로 포맷할 수 있다.

이후 모든 대답을 여기지만 유산 자바 또는 joda거나 비슷한 3파티 libs를 인용고 난 방금 자바 8에서 새로운 java.time 클래스를 사용하여 다른 방법으로 떨어질 것입니다.참고 오라클 Tutorial.

사용 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 );

만약 당신이 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의 수는 언제나 같은(일광 절약 시간과 도약초 때문에)그러나 그것은 가까운 것, 그리고 최소한 편차 일광을 긴 시간에 걸쳐 취소 시간을 절약할 예정.따라서 다음 라운딩 분류하면서, 정확한 결과(적어도에서 국내 달력 사용되는 이상한 시간 점프 일광 절약 시간 이외의 도약초가 포함되어 있지 않)을 줄것이다.

이 아직도 이 아직도 그 가정은 참곤다고 가정합니다.date1그리고.date2같은 시간 준비 되셨나.같은시간 준비 되셨나.로 존 스키트에 의해 지적된 하루의 다른 시간에는 먼저"날짜 차이"의 의미가 무엇인지를 정하는 것은 했다.로 존 스키트에 의해 지적된 하루의 다른 시간에는 먼저"날짜 차이"의 의미가 무엇인지를 정하는 것은 했다.

밀리초의 날짜 Subtracting(로 다른 우편물에 설명한),지만 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
}

Joda 시간을 두고 있는 fine 스칼라와 연구해야 하는 개선된 날짜/시간 API자바에 있는 것에 보세요.

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

나 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 아르젠티노 사우루스 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;
}

:endDates -> 있다;java.util startDate습니다.날짜

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이 예제 요즘, 시간, 분,secs고 밀리초의 차이:)을 준다 예를 점검한다.

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시간대는 달력의 인스턴스를 가져올, 달력 클래스의 집합을 메서드를 사용하여 시간을 정하다.그 GMTtimezone 0오프셋(별로 중요한)과 일광 절약 시간 국기 나일론을 정했다.

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

걸로 하는 것이다.

(Date1-Date2)/86 400 000

밀리초의 하루에 그 숫자이다.

어느 date-other 날짜 밀리초 단위로 차이를 준 것입니다.

이중 변수에서 그 답을 모읍니다.

여기 O(1)에 의존성 없이 정확한 자바 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;
}

다른 모든 대답을 훑어보고, 하지만 더는 자바 8연락 접근 방법과precise/standard이 자바 7날짜 형식을 유지하기 위해 걸어서 건넌 후.

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

그게 아마도 가장 간단한 방법-자바(그것의 명백하게 투박한 날짜와 시간 도서관을 갖춘)에 한동안 코딩해 왔어요 아마도, 하지만 그 암호" 간단하고 멋진"나한테!

당신의 그 결과에 행복하니 밀리초 단위로 또는 당신의 질문에 사용자가 대체 형식으로 반환될 수 있기를 더 좋아할 것이 일부 돌아오는 것?

표준 API, 번호를 통하지 않아당신은 이와 같은 일을 하기:나만의 굴릴 수 있다.

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

아니면:Joda 사용할 수 있다.

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

그냥 초기 질문에 대답할

기능 긴 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;

가장 중요할 때와 분열하고, 또한 multiplying한 것 긴 숫자들과 일하는 것이다.그리고 물론, 오프셋 자바로 한의 미적분학에서 적용된다.

그 질문부터 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

만약 당신은 일광 절약 시간 경계(여름 시간에 예를 들어 한 날짜와 다른 하나는 겨울 시간에)를 건널 때 날짜 범위하기 위해서 그 문제를 고치고 싶다면, 요즘의 차이:이 사용할 수 있다.

public static long calculateDifferenceInDays(Date start, Date end, Locale locale) {
    Calendar cal = Calendar.getInstance(locale);

    cal.setTime(start);
    cal.set(Calendar.HOUR_OF_DAY, 0);
    cal.set(Calendar.MINUTE, 0);
    cal.set(Calendar.SECOND, 0);
    cal.set(Calendar.MILLISECOND, 0);
    long startTime = cal.getTimeInMillis();

    cal.setTime(end);
    cal.set(Calendar.HOUR_OF_DAY, 0);
    cal.set(Calendar.MINUTE, 0);
    cal.set(Calendar.SECOND, 0);
    cal.set(Calendar.MILLISECOND, 0);
    long endTime = cal.getTimeInMillis();

    // calculate the offset if one of the dates is in summer time and the other one in winter time
    TimeZone timezone = cal.getTimeZone();
    int offsetStart = timezone.getOffset(startTime);
    int offsetEnd = timezone.getOffset(endTime);
    int offset = offsetEnd - offsetStart;

    return TimeUnit.MILLISECONDS.toDays(endTime - startTime + offset);
}

언급URL:https://stackoverflow.com/questions/1555262/calculating-the-difference-between-two-java-date-instances

'Programing' 카테고리의 다른 글

Vuex 저장소의 슬라이더 설정 값 확인 (0)	2022.05.18
Java 반사:변수 이름을 얻는 방법? (0)	2022.05.17
Vue.js의 다른 구성 요소에서 호출 방법 (0)	2022.05.17
JS 파일의 Nuxt 액세스 저장소(모듈 모드) (0)	2022.05.17
vuej에서 처리된 html 잘라내기 (0)	2022.05.17

현재글2자바 날짜 인스턴스의 차이를 계산 중입니다

c10106

2자바 날짜 인스턴스의 차이를 계산 중입니다

2자바 날짜 인스턴스의 차이를 계산 중입니다

간단한 연락(lib 없이)

인간의 읽기 쉬운 연락(lib 없이).

경고

JodaTime으로

한줄 요약

ISO8601형식:ISO8601형식:`PnYnMnDTnHnMnS`

자바.시간

모멘트

시간의 무엇일까

`ChronoUnit`

java.time 정보

조다 타임

'Programing' 카테고리의 다른 글

'Programing'의 다른글

티스토리툴바

2자바 날짜 인스턴스의 차이를 계산 중입니다

2자바 날짜 인스턴스의 차이를 계산 중입니다

간단한 연락(lib 없이)

인간의 읽기 쉬운 연락(lib 없이).

경고

JodaTime으로

한줄 요약

ISO8601형식:ISO8601형식:PnYnMnDTnHnMnS

자바.시간

모멘트

시간의 무엇일까

ChronoUnit

java.time 정보

조다 타임

'Programing' 카테고리의 다른 글

'Programing'의 다른글

관련글

티스토리툴바

ISO8601형식:ISO8601형식:`PnYnMnDTnHnMnS`

`ChronoUnit`