Tôi đang sử dụng java.util.Datelớp của Java trong Scala và muốn so sánh một Dateđối tượng và thời điểm hiện tại. Tôi biết tôi có thể tính toán delta bằng cách sử dụng getTime ():

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

Tuy nhiên, điều này chỉ để lại cho tôi một longphần nghìn giây. Có cách nào đơn giản hơn, đẹp hơn để có được đồng bằng thời gian không?

DateAPI JDK bị hỏng một cách khủng khiếp. Tôi khuyên bạn nên sử dụng thư viện Joda Time .

Joda Time có một khái niệm về khoảng thời gian :

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

EDIT: Nhân tiện, Joda có hai khái niệm: Intervalđể biểu thị một khoảng thời gian giữa hai thời gian thực (đại diện cho thời gian từ 8 giờ sáng đến 10 giờ sáng) và Durationđại diện cho một khoảng thời gian không có ranh giới thời gian thực tế (ví dụ: đại diện cho hai giờ!)

Nếu bạn chỉ quan tâm đến việc so sánh thời gian, hầu hết các Datetriển khai (bao gồm cả JDK) đều thực hiện Comparablegiao diện cho phép bạn sử dụngComparable.compareTo()

Khác biệt đơn giản (không có 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);
}

Và sau đó bạn có thể gọi:

getDateDiff(date1,date2,TimeUnit.MINUTES);

để có được độ lệch của 2 ngày tính theo đơn vị phút.

TimeUnitlà java.util.concurrent.TimeUnit, một enum Java tiêu chuẩn đi từ nano đến ngày.

Khác biệt có thể đọc được của con người (không có 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

Đầu ra là một cái gì đó như Map:{DAYS=1, HOURS=3, MINUTES=46, SECONDS=40, MILLISECONDS=0, MICROSECONDS=0, NANOSECONDS=0}, với các đơn vị đặt hàng.

Bạn chỉ cần chuyển đổi bản đồ đó thành một chuỗi thân thiện với người dùng.

Cảnh báo

Đoạn mã trên tính toán một sự khác biệt đơn giản giữa 2 instants. Nó có thể gây ra vấn đề trong một công tắc tiết kiệm ánh sáng ban ngày, như được giải thích trong bài viết này . Điều này có nghĩa là nếu bạn tính chênh lệch giữa các ngày mà không có thời gian bạn có thể thiếu một ngày / giờ.

Theo tôi thì ngày diff là loại chủ quan, đặc biệt là vào những ngày. Bạn có thể:

• đếm số lượng thời gian đã trôi qua 24h: ngày + 1 - ngày = 1 ngày = 24h

• đếm số lượng thời gian đã trôi qua, chăm sóc tiết kiệm ánh sáng ban ngày: ngày + 1 - ngày = 1 = 24h (nhưng sử dụng thời gian nửa đêm và tiết kiệm ánh sáng ban ngày có thể là 0 ngày và 23h)

• đếm số lượng day switches, có nghĩa là ngày + 1 giờ chiều - ngày 11 giờ = 1 ngày, ngay cả khi thời gian đã trôi qua chỉ là 2h (hoặc 1h nếu có tiết kiệm ánh sáng ban ngày: p)

Câu trả lời của tôi là hợp lệ nếu định nghĩa ngày khác của bạn vào các ngày khớp với trường hợp thứ nhất

Với JodaTime

Nếu bạn đang sử dụng JodaTime, bạn có thể nhận được diff cho 2 ngày (millies được hỗ trợ ReadableInstant) với:

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

Nhưng bạn cũng có thể nhận được khác biệt cho ngày / lần địa phương:

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

Lưu ý rằng điều này hoạt động với ngày UTC, vì vậy sự khác biệt có thể là một ngày nghỉ nếu bạn nhìn vào ngày địa phương. Và để nó hoạt động chính xác với ngày địa phương đòi hỏi một cách tiếp cận hoàn toàn khác do thời gian tiết kiệm ánh sáng ban ngày.

Sử dụng khung java.time được tích hợp trong 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());

Đầu ra:

ISO-8601: PT24H10M

Phút: 1450

Để biết thêm thông tin, hãy xem Hướng dẫn của Oracle và tiêu chuẩn ISO 8601 .

Bạn cần xác định vấn đề của bạn rõ ràng hơn. Bạn chỉ có thể lấy số mili giây giữa hai Dateđối tượng và chia cho số mili giây trong 24 giờ, ví dụ ... nhưng:

• Điều này sẽ không xem xét các múi giờ - Dateluôn có trong UTC
• Điều này sẽ không mất thời gian tiết kiệm ánh sáng ban ngày (ví dụ, nơi có thể có những ngày chỉ dài 23 giờ)
• Ngay cả trong UTC, có bao nhiêu ngày trong 16 tháng 11, 11 giờ tối đến 18 tháng 8, 2 giờ sáng? Chỉ có 27 giờ, vậy có nghĩa là một ngày? Hoặc nên là ba ngày bởi vì nó bao gồm ba ngày?

tl; dr

Chuyển đổi các java.util.Dateđối tượng lỗi thời của bạn để thay thế chúng , java.time.Instant. Sau đó tính thời gian trôi qua là 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

Định dạng ISO 8601: PnYnMnDTnHnMnS

Tiêu chuẩn hợp lý ISO 8601 định nghĩa một biểu diễn văn bản ngắn gọn của một khoảng thời gian là một số năm, tháng, ngày, giờ, v.v. Tiêu chuẩn gọi như vậy trong một khoảng thời gian . Định dạng là PnYnMnDTnHnMnSnơi Pcó nghĩa là "Thời gian", phần Ttách biệt ngày với phần thời gian và ở giữa là các số được theo sau bởi một chữ cái.

Ví dụ:

• P3Y6M4DT12H30M5S
  ba năm, sáu tháng, bốn ngày, mười hai giờ, ba mươi phút và năm giây
• PT4H30M
  Bốn giờ rưỡi

java.time

Các java.time khuôn khổ xây dựng vào Java 8 và sau đó chiếm chỗ cũ phiền hà java.util.Date/ java.util.Calendarlớp. Các lớp mới được lấy cảm hứng từ khuôn khổ Joda-Time rất thành công , dự định là người kế thừa của nó, tương tự về khái niệm nhưng được tái kiến ​​trúc. Được xác định bởi JSR 310 . Mở rộng bởi dự án ThreeTen-Extra . Xem hướng dẫn .

Chốc lát

Các Instantlớp đại diện cho một thời điểm trên Timeline trong UTC với độ phân giải nano giây (lên đến chín (9) chữ số của một phân số thập phân).

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

Tốt nhất để tránh các lớp kế thừa như Date/ Calendar. Nhưng nếu bạn phải tương tác với mã cũ chưa được cập nhật lên java.time , hãy chuyển đổi qua lại. Gọi các phương thức chuyển đổi mới được thêm vào các lớp cũ. Để chuyển từ a java.util.Datesang an Instant, hãy gọi Date::toInstant.

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

Khoảng thời gian

Các lớp java.time đã chia ý tưởng này đại diện cho một khoảng thời gian là một số năm, tháng, ngày, giờ, phút, giây thành hai nửa:

• Period trong nhiều năm, tháng, ngày
• Duration cho ngày, giờ, phút, giây

Đây là một ví dụ.

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

Đổ vào bàn điều khiển.

Cả hai Periodvà Durationsử dụng tiêu chuẩn ISO 8601 để tạo đại diện Chuỗi cho giá trị của chúng.

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

ngay bây giờ: 2015-11-26T00: 46: 48.016-05: 00 [America / Montreal] tới tương lai: 2015-11-26T00: 46: 48.016-05: 00 [America / Montreal] = PT1H3M

Java 9 thêm các phương thức để Durationcó được phần ngày, phần giờ, phần phút và phần giây.

Bạn có thể nhận được tổng số ngày hoặc giờ hoặc phút hoặc giây hoặc mili giây hoặc nano giây trong toàn bộ Thời lượng.

long totalHours = duration.toHours();

Trong Java 9, Durationlớp nhận được các phương thức mới để trả về các phần khác nhau của ngày, giờ, phút, giây, mili giây / nano giây. Gọi to…Partphương pháp: toDaysPart(), toHoursPart(), và vân vân.

ChronoUnit

Nếu bạn chỉ quan tâm đến độ chi tiết thời gian lớn hơn đơn giản hơn, chẳng hạn như số ngày trôi qua, hãy sử dụng ChronoUnitenum.

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

Một vi dụ khac.

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

120

Giới thiệu về java.time

Các java.time khung được xây dựng vào Java 8 và sau đó. Những lớp học thay thế cái cũ phiền hà di sản lớp học ngày thời gian như java.util.Date, Calendar, & SimpleDateFormat.

Các Joda thời gian dự án, bây giờ trong chế độ bảo trì , khuyên chuyển đổi sang java.time.

Để tìm hiểu thêm, xem Hướng dẫn Oracle . Và tìm kiếm Stack Overflow cho nhiều ví dụ và giải thích. Đặc điểm kỹ thuật là JSR 310 .

Nơi để có được các lớp java.time?

• Java SE 8 và SE 9 trở lên
  • Được xây dựng trong.
  • Một phần của API Java tiêu chuẩn với việc triển khai đi kèm.
  • Java 9 thêm một số tính năng nhỏ và sửa lỗi.
• Java SE 6 và SE 7
  • Phần lớn chức năng java.time được chuyển ngược lại sang Java 6 & 7 trong ThreeTen-Backport .
• Android
  • Các ThreeTenABP dự án thích nghi ThreeTen-backport (nêu trên) cho Android cụ thể.
  • Xem Cách sử dụng .

Các ThreeTen-Extra dự án mở rộng java.time với các lớp bổ sung. Dự án này là một nền tảng chứng minh cho các bổ sung có thể trong tương lai cho java.time. Bạn có thể tìm thấy một số các lớp học hữu ích ở đây chẳng hạn như Interval, YearWeek, YearQuarter, và nhiều hơn nữa .

Joda-Thời gian

CẬP NHẬT: Dự án Joda-Time hiện đang ở chế độ bảo trì , với nhóm tư vấn di chuyển sang các lớp java.time . Tôi để phần này nguyên vẹn cho lịch sử.

Thư viện Joda-Time sử dụng ISO 8601 cho các mặc định của nó. PeriodLớp của nó phân tích cú pháp và tạo ra các chuỗi PnYnMnDTnHnMnS này.

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

Riders:

period: PT4H30M

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

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

Một thay thế đơn giản hơn một chút:

System.currentTimeMillis() - oldDate.getTime()

Đối với "đẹp hơn": tốt, chính xác những gì bạn cần? Vấn đề với việc biểu thị thời lượng là một số giờ và ngày, vv là nó có thể dẫn đến sự không chính xác và kỳ vọng sai do sự phức tạp của ngày (ví dụ: ngày có thể có 23 hoặc 25 giờ do thời gian tiết kiệm ánh sáng ban ngày).

Sử dụng phương pháp mili giây có thể gây ra vấn đề ở một số địa phương.

Ví dụ, hãy lấy sự khác biệt giữa hai ngày 24/03/2007 và 25/03/2007 là 1 ngày;

Tuy nhiên, sử dụng tuyến đường mili giây, bạn sẽ nhận được 0 ngày, nếu bạn chạy tuyến đường này ở Vương quốc Anh!

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

Cách tốt hơn để thực hiện điều này là sử dụng java.util.CalWiki

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

Có nhiều cách bạn có thể tìm thấy sự khác biệt giữa ngày và thời gian. Một trong những cách đơn giản nhất mà tôi biết sẽ là:

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

Câu lệnh in chỉ là một ví dụ - bạn có thể định dạng nó, theo cách bạn muốn.

Vì tất cả các câu trả lời ở đây đều đúng nhưng sử dụng các lib của java hoặc bên thứ 3 như joda hoặc tương tự, tôi sẽ bỏ cách khác bằng cách sử dụng các lớp java.time mới trong Java 8 trở lên. Xem Hướng dẫn của Oracle .

Sử dụng LocalDatevà 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 );

Trừ các ngày tính bằng mili giây hoạt động (như được mô tả trong bài đăng khác), nhưng bạn phải sử dụng HOUR_OF_DAY và không GIỜ khi xóa các phần thời gian trong ngày của bạn:

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
}

Nếu bạn không muốn sử dụng JodaTime hoặc tương tự, giải pháp tốt nhất có lẽ là:

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

Số ms mỗi ngày không phải lúc nào cũng giống nhau (vì thời gian tiết kiệm ánh sáng ban ngày và giây nhuận), nhưng nó rất gần và ít nhất là sai lệch do thời gian tiết kiệm ánh sáng ban ngày hủy bỏ trong thời gian dài hơn. Do đó, việc chia và làm tròn sẽ cho kết quả chính xác (ít nhất là miễn là lịch địa phương được sử dụng không chứa các bước nhảy kỳ lạ khác với DST và giây nhuận).

Lưu ý rằng điều này vẫn giả định rằng date1và date2được đặt cùng thời gian trong ngày. Đối với các thời điểm khác nhau trong ngày, trước tiên bạn phải xác định "chênh lệch ngày" nghĩa là gì, như Jon Skeet đã chỉ ra.

Hãy xem Joda Time , đây là API Ngày / Giờ được cải tiến cho Java và sẽ hoạt động tốt với Scala.

Hãy để tôi cho thấy sự khác biệt giữa Joda Interval và 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 

Nếu bạn cần một chuỗi trả về được định dạng như "2 ngày 03h 42m 07s", hãy thử điều này:

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

Lưu ý: startDate và endDates là -> 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();

và ngày kết thúc

Tương tự như ngày, bạn cũng có thể nhận được giờ, phút và giây

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

Kiểm tra ví dụ ở đây http://www.roseindia.net/java/beginners/DateDifferent.shtml Ví dụ này cung cấp cho bạn sự khác biệt về ngày, giờ, phút, giây và milli giây :).

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

Sử dụng múi giờ GMT để lấy phiên bản của Lịch, đặt thời gian bằng cách sử dụng phương thức đã đặt của lớp Lịch. Múi giờ GMT có 0 bù (không thực sự quan trọng) và cờ thời gian tiết kiệm ánh sáng ban ngày được đặt thành sai.

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

Mã sau có thể cung cấp cho bạn đầu ra mong muốn:

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;

Điều tốt nhất để làm là

(Date1-Date2)/86 400 000 

Con số đó là số mili giây trong một ngày.

Một ngày - ngày khác cung cấp cho bạn sự khác biệt tính bằng mili giây.

Thu thập câu trả lời trong một biến kép .

Đây là một giải pháp Java 7 chính xác trong O (1) mà không có bất kỳ phụ thuộc nào.

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

Đó có lẽ là cách đơn giản nhất để làm điều đó - có lẽ đó là vì tôi đã mã hóa bằng Java (với các thư viện ngày và giờ được thừa nhận của nó) trong một thời gian, nhưng mã đó có vẻ "đơn giản và tốt đẹp" đối với tôi!

Bạn có hài lòng với kết quả được trả về sau mili giây hay là một phần câu hỏi của bạn mà bạn muốn trả lại ở một số định dạng thay thế?

Không sử dụng API tiêu chuẩn, không. Bạn có thể tự mình làm một cái gì đó như thế này:

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

Hoặc bạn có thể sử dụng Joda :

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

Chỉ để trả lời câu hỏi ban đầu:

Đặt mã sau vào Hàm như 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;

Điều quan trọng nhất ở đây là làm việc với các số dài khi nhân và chia. Và tất nhiên, phần bù mà Java áp dụng trong phép tính Ngày của nó.

:)

Vì câu hỏi được gắn thẻ với 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

Sau khi lội qua tất cả các câu trả lời khác, để giữ loại Ngày của Java 7 nhưng chính xác hơn / tiêu chuẩn hơn với cách tiếp cận khác biệt của Java 8,

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

thử cái này:

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

bạn có thể chỉnh sửa chuỗi trong phương thức parse () param.