java

Question 1

두 날짜 사이의 일 수 를 찾아야합니다 . 하나는 보고서에서 가져온 것이고 다른 하나는 현재 날짜입니다. 내 스 니펫 :

  int age=calculateDifference(agingDate, today);

여기에 calculateDifference개인 방법이다, agingDate하고 today있는 Date당신의 명확한 설명, 객체. Java 포럼의 두 기사 인 Thread 1 / Thread 2를 따랐습니다 .

독립 실행 형 프로그램에서 잘 작동하지만 보고서에서 읽을 논리에 이것을 포함하면 값에서 비정상적인 차이가 발생합니다.

왜 발생하며 어떻게 해결할 수 있습니까?

편집하다 :

실제 일수에 비해 더 많은 일수를 얻고 있습니다.

public static int calculateDifference(Date a, Date b)
{
    int tempDifference = 0;
    int difference = 0;
    Calendar earlier = Calendar.getInstance();
    Calendar later = Calendar.getInstance();

    if (a.compareTo(b) < 0)
    {
        earlier.setTime(a);
        later.setTime(b);
    }
    else
    {
        earlier.setTime(b);
        later.setTime(a);
    }

    while (earlier.get(Calendar.YEAR) != later.get(Calendar.YEAR))
    {
        tempDifference = 365 * (later.get(Calendar.YEAR) - earlier.get(Calendar.YEAR));
        difference += tempDifference;

        earlier.add(Calendar.DAY_OF_YEAR, tempDifference);
    }

    if (earlier.get(Calendar.DAY_OF_YEAR) != later.get(Calendar.DAY_OF_YEAR))
    {
        tempDifference = later.get(Calendar.DAY_OF_YEAR) - earlier.get(Calendar.DAY_OF_YEAR);
        difference += tempDifference;

        earlier.add(Calendar.DAY_OF_YEAR, tempDifference);
    }

    return difference;
}

노트 :

불행히도 어떤 답변도 문제 해결에 도움이되지 않았습니다. 내가 이룬 이 문제 의 도움으로 Joda 타임 라이브러리를.

Question 2

결함이있는 java.util.Date 및 친구들 대신 우수한 Joda Time 라이브러리 를 사용하는 것이 좋습니다 . 당신은 단순히 쓸 수 있습니다

import java.util.Date;
import org.joda.time.DateTime;
import org.joda.time.Days;

Date past = new Date(110, 5, 20); // June 20th, 2010
Date today = new Date(110, 6, 24); // July 24th 
int days = Days.daysBetween(new DateTime(past), new DateTime(today)).getDays(); // => 34

Question 3

게임에 참여하기에는 너무 늦었을 수도 있지만 대체 뭐야? 🙂

이것이 스레딩 문제라고 생각하십니까? 예를 들어이 방법의 출력을 어떻게 사용하고 있습니까? 또는

다음과 같이 간단한 작업을 수행하도록 코드를 변경할 수 있습니까?

Calendar calendar1 = Calendar.getInstance();
    Calendar calendar2 = Calendar.getInstance();
    calendar1.set(<your earlier date>);
    calendar2.set(<your current date>);
    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.");
  }

Question 4

diff / (24 * etc)는 시간대를 고려하지 않으므로 기본 시간대에 DST가있는 경우 계산이 중단 될 수 있습니다.

이 링크 는 멋진 작은 구현을 가지고 있습니다.

링크가 다운되는 경우 위 링크의 소스는 다음과 같습니다.

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

과

/** Using Calendar - THE CORRECT (& Faster) WAY**/
public static long daysBetween(final Calendar startDate, final Calendar endDate)
{
  //assert: startDate must be before endDate  
  int MILLIS_IN_DAY = 1000 * 60 * 60 * 24;
  long endInstant = endDate.getTimeInMillis();
  int presumedDays =
    (int) ((endInstant - startDate.getTimeInMillis()) / MILLIS_IN_DAY);
  Calendar cursor = (Calendar) startDate.clone();
  cursor.add(Calendar.DAY_OF_YEAR, presumedDays);
  long instant = cursor.getTimeInMillis();
  if (instant == endInstant)
    return presumedDays;

  final int step = instant < endInstant ? 1 : -1;
  do {
    cursor.add(Calendar.DAY_OF_MONTH, step);
    presumedDays += step;
  } while (cursor.getTimeInMillis() != endInstant);
  return presumedDays;
}

Question 5

java.time

Java 8 이상에서는 java.time 프레임 워크 ( Tutorial )를 사용하십시오 .

`Duration`

이 Duration클래스는 시간 범위를 초 수와 분수 초로 나타냅니다. 일, 시간, 분 및 초를 계산할 수 있습니다.

ZonedDateTime now = ZonedDateTime.now();
ZonedDateTime oldDate = now.minusDays(1).minusMinutes(10);
Duration duration = Duration.between(oldDate, now);
System.out.println(duration.toDays());

`ChronoUnit`

필요한 것이 일수뿐이라면 enum을 사용할 수 있습니다 . 계산 방법 은 .ChronoUnit longint

long days = ChronoUnit.DAYS.between( then, now );

Question 6

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

public class Main {
    public static long calculateDays(String startDate, String endDate)
    {
        Date sDate = new Date(startDate);
        Date eDate = new Date(endDate);
        Calendar cal3 = Calendar.getInstance();
        cal3.setTime(sDate);
        Calendar cal4 = Calendar.getInstance();
        cal4.setTime(eDate);
        return daysBetween(cal3, cal4);
    }

    public static void main(String[] args) {
        System.out.println(calculateDays("2012/03/31", "2012/06/17"));

    }

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

Question 7

차이로 정의한 내용에 따라 다릅니다. 자정에 두 날짜를 비교하려면 할 수 있습니다.

long day1 = ...; // in milliseconds.
long day2 = ...; // in milliseconds.
long days = (day2 - day1) / 86400000;

Question 8

DST 날짜에 대한 올바른 반올림과 함께 밀리 초 시간의 차이를 사용하는 솔루션 :

public static long daysDiff(Date from, Date to) {
    return daysDiff(from.getTime(), to.getTime());
}

public static long daysDiff(long from, long to) {
    return Math.round( (to - from) / 86400000D ); // 1000 * 60 * 60 * 24
}

한 가지 참고 : 물론 날짜는 일부 시간대 여야합니다.

중요한 코드 :

Math.round( (to - from) / 86400000D )

라운드를 원하지 않으면 UTC 날짜를 사용할 수 있습니다.