Saya mencoba menghitung perbedaan antara dua LocalDateTime .

Keluaran harus dalam format y years m months d days h hours m minutes s seconds . Inilah yang saya tulis:

import java.time.Duration;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.Period;
import java.time.ZoneId;

public class Main {

    static final int MINUTES_PER_HOUR = 60;
    static final int SECONDS_PER_MINUTE = 60;
    static final int SECONDS_PER_HOUR = SECONDS_PER_MINUTE * MINUTES_PER_HOUR;

    public static void main(String[] args) {
        LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 9, 19, 46, 45);
        LocalDateTime fromDateTime = LocalDateTime.of(1984, 12, 16, 7, 45, 55);

        Period period = getPeriod(fromDateTime, toDateTime);
        long time[] = getTime(fromDateTime, toDateTime);

        System.out.println(period.getYears() + " years " + 
                period.getMonths() + " months " + 
                period.getDays() + " days " +
                time[0] + " hours " +
                time[1] + " minutes " +
                time[2] + " seconds.");


    }

    private static Period getPeriod(LocalDateTime dob, LocalDateTime now) {
        return Period.between(dob.toLocalDate(), now.toLocalDate());
    }

    private static long[] getTime(LocalDateTime dob, LocalDateTime now) {
        LocalDateTime today = LocalDateTime.of(now.getYear(),
                now.getMonthValue(), now.getDayOfMonth(), dob.getHour(), dob.getMinute(), dob.getSecond());
        Duration duration = Duration.between(today, now);

        long seconds = duration.getSeconds();

        long hours = seconds / SECONDS_PER_HOUR;
        long minutes = ((seconds % SECONDS_PER_HOUR) / SECONDS_PER_MINUTE);
        long secs = (seconds % SECONDS_PER_MINUTE);

        return new long[]{hours, minutes, secs};
    }
}

Output yang saya dapatkan adalah 29 years 8 months 24 days 12 hours 0 minutes 50 seconds. Saya telah memeriksa hasil saya dari situs web ini (dengan nilai-nilai12/16/1984 07:45:55 dan 09/09/2014 19:46:45). Tangkapan layar berikut menunjukkan output:

Saya cukup yakin bahwa bidang setelah nilai bulan salah dari kode saya. Setiap saran akan sangat membantu.

Memperbarui

Saya telah menguji hasil saya dari situs web lain dan hasil yang saya dapatkan berbeda. Ini dia: Hitung durasi antara dua tanggal (hasil: 29 tahun, 8 bulan, 24 hari, 12 jam, 0 menit dan 50 detik).

Memperbarui

Karena saya mendapat dua hasil berbeda dari dua situs yang berbeda, saya bertanya-tanya apakah algoritma perhitungan saya sah atau tidak. Jika saya menggunakan dua LocalDateTimeobjek berikut :

LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 10, 6, 40, 45);
LocalDateTime fromDateTime = LocalDateTime.of(1984, 12, 16, 7, 45, 55);

Maka output akan datang: 29 years 8 months 25 days -1 hours -5 minutes -10 seconds.

Dari tautan ini seharusnya29 years 8 months 24 days 22 hours, 54 minutes and 50 seconds . Jadi algoritma perlu menangani angka negatif juga.

Perhatikan pertanyaannya bukan tentang situs mana yang memberi saya hasil apa, saya perlu tahu algoritma yang tepat dan harus memiliki hasil yang benar.

Sayangnya, sepertinya tidak ada kelas periode yang mencakup waktu juga, jadi Anda mungkin harus melakukan perhitungan sendiri.

Untungnya, kelas tanggal dan waktu memiliki banyak metode utilitas yang menyederhanakannya sampai tingkat tertentu. Berikut adalah cara untuk menghitung perbedaan meskipun tidak selalu yang tercepat:

LocalDateTime fromDateTime = LocalDateTime.of(1984, 12, 16, 7, 45, 55);
LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 10, 6, 40, 45);

LocalDateTime tempDateTime = LocalDateTime.from( fromDateTime );

long years = tempDateTime.until( toDateTime, ChronoUnit.YEARS );
tempDateTime = tempDateTime.plusYears( years );

long months = tempDateTime.until( toDateTime, ChronoUnit.MONTHS );
tempDateTime = tempDateTime.plusMonths( months );

long days = tempDateTime.until( toDateTime, ChronoUnit.DAYS );
tempDateTime = tempDateTime.plusDays( days );


long hours = tempDateTime.until( toDateTime, ChronoUnit.HOURS );
tempDateTime = tempDateTime.plusHours( hours );

long minutes = tempDateTime.until( toDateTime, ChronoUnit.MINUTES );
tempDateTime = tempDateTime.plusMinutes( minutes );

long seconds = tempDateTime.until( toDateTime, ChronoUnit.SECONDS );

System.out.println( years + " years " + 
        months + " months " + 
        days + " days " +
        hours + " hours " +
        minutes + " minutes " +
        seconds + " seconds.");

//prints: 29 years 8 months 24 days 22 hours 54 minutes 50 seconds.

Ide dasarnya adalah ini: buat tanggal mulai sementara dan dapatkan tahun penuh hingga akhir. Kemudian sesuaikan tanggal dengan jumlah tahun sehingga tanggal mulai kurang dari satu tahun dari akhir. Ulangi itu untuk setiap unit waktu dalam urutan menurun.

Akhirnya penafian : Saya tidak memperhitungkan zona waktu yang berbeda (kedua tanggal harus dalam zona waktu yang sama) dan saya juga tidak menguji / memeriksa bagaimana waktu musim panas atau perubahan lain dalam kalender (seperti perubahan zona waktu di Samoa) mempengaruhi perhitungan ini. Jadi gunakan dengan hati-hati.

Saya menemukan cara terbaik untuk melakukan ini adalah dengan ChronoUnit.

long minutes = ChronoUnit.MINUTES.between(fromDate, toDate);
long hours = ChronoUnit.HOURS.between(fromDate, toDate);

Dokumentasi tambahan ada di sini: https://docs.oracle.com/javase/tutorial/datetime/iso/ period.html

Berikut satu contoh menggunakan Duration dan TimeUnit untuk mendapatkan format 'hh: mm: ss'.

Duration dur = Duration.between(localDateTimeIni, localDateTimeEnd);
long millis = dur.toMillis();

String.format("%02d:%02d:%02d", 
        TimeUnit.MILLISECONDS.toHours(millis),
        TimeUnit.MILLISECONDS.toMinutes(millis) - 
        TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)),
        TimeUnit.MILLISECONDS.toSeconds(millis) - 
        TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)));

Itu harus lebih sederhana!

Duration.between(startLocalDateTime, endLocalDateTime).toMillis();

TL; DR

Duration duration = Duration.between(start, end);
duration = duration.minusDays(duration.toDaysPart()); // essentially "duration (mod 1 day)"
Period period = Period.between(start.toLocalDate(), end.toLocalDate());

dan kemudian menggunakan metode period.getYears(), period.getMonths(), period.getDays(), duration.toHoursPart(), duration.toMinutesPart(), duration.toSecondsPart().

Jawaban diperluas

Saya akan menjawab pertanyaan awal, yaitu bagaimana mendapatkan perbedaan waktu antara dua LocalDateTimestahun, bulan, hari, jam & menit, sehingga "jumlah" (lihat catatan di bawah) dari semua nilai untuk unit yang berbeda sama dengan total perbedaan temporal, dan sedemikian rupa sehingga nilai di setiap unit lebih kecil dari unit yang lebih besar berikutnya — yaitu minutes < 60,hours < 24 dan seterusnya.

Diberi dua LocalDateTimes startdan end, mis

LocalDateTime start = LocalDateTime.of(2019, 11, 29, 17, 15);
LocalDateTime end = LocalDateTime.of(2020, 11, 30, 18, 44);

kita dapat mewakili rentang waktu absolut antara keduanya dengan Duration—mungkin menggunakan Duration.between(start, end). Tetapi unit terbesar yang dapat kita ambil dari a Durationadalah hari (sebagai unit temporal yang setara dengan 24 jam) —lihat catatan di bawah ini untuk penjelasan. Untuk menggunakan unit yang lebih besar (bulan, tahun) kami dapat mewakili ini Durationdengan sepasang ( Period, Duration), di mana Periodmengukur perbedaan hingga presisi hari dan Durationsisanya mewakili:

Duration duration = Duration.between(start, end);
duration = duration.minusDays(duration.toDaysPart()); // essentially "duration (mod 1 day)"
Period period = Period.between(start.toLocalDate(), end.toLocalDate());

Sekarang kita cukup menggunakan metode yang didefinisikan Perioddan Durationuntuk mengekstrak unit individu:

System.out.printf("%d years, %d months, %d days, %d hours, %d minutes, %d seconds",
        period.getYears(), period.getMonths(), period.getDays(), duration.toHoursPart(),
        duration.toMinutesPart(), duration.toSecondsPart());

1 years, 0 months, 1 days, 1 hours, 29 minutes, 0 seconds

atau, menggunakan format default:

System.out.println(period + " + " + duration);

P1Y1D + PT1H29M

Perhatikan tahun, bulan & hari

Perhatikan bahwa, dalam java.timekonsepsi, "unit" seperti "bulan" atau "tahun" tidak mewakili nilai temporal absolut yang tetap — bergantung pada tanggal dan kalender, seperti yang diilustrasikan oleh contoh berikut:

LocalDateTime
        start1 = LocalDateTime.of(2020, 1, 1, 0, 0),
        end1 = LocalDateTime.of(2021, 1, 1, 0, 0),
        start2 = LocalDateTime.of(2021, 1, 1, 0, 0),
        end2 = LocalDateTime.of(2022, 1, 1, 0, 0);
System.out.println(Period.between(start1.toLocalDate(), end1.toLocalDate()));
System.out.println(Duration.between(start1, end1).toDays());
System.out.println(Period.between(start2.toLocalDate(), end2.toLocalDate()));
System.out.println(Duration.between(start2, end2).toDays());

P1Y
366
P1Y
365

Ada beberapa masalah untuk kode Tapas Bose dan kode Thomas. Jika perbedaan waktu adalah negatif, array mendapat nilai negatif. Misalnya jika

LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 10, 6, 46, 45);
LocalDateTime fromDateTime = LocalDateTime.of(2014, 9, 9, 7, 46, 45);

ia mengembalikan 0 tahun 0 bulan 1 hari -1 jam 0 menit 0 detik.

Saya pikir output yang tepat adalah: 0 tahun 0 bulan 0 hari 23 jam 0 menit 0 detik.

Saya mengusulkan untuk memisahkan instance LocalDateTime pada instance LocalDate dan LocalTime. Setelah itu kita bisa mendapatkan contoh Periode dan Durasi Java 8. Contoh Durasi dipisahkan pada jumlah hari dan nilai waktu sepanjang hari (<24jam) dengan koreksi selanjutnya dari nilai periode. Ketika nilai LocalTime kedua adalah sebelum nilai firstLocalTime, perlu untuk mengurangi periode selama satu hari.

Inilah cara saya untuk menghitung perbedaan LocalDateTime:

private void getChronoUnitForSecondAfterFirst(LocalDateTime firstLocalDateTime, LocalDateTime secondLocalDateTime, long[] chronoUnits) {
    /*Separate LocaldateTime on LocalDate and LocalTime*/
    LocalDate firstLocalDate = firstLocalDateTime.toLocalDate();
    LocalTime firstLocalTime = firstLocalDateTime.toLocalTime();

    LocalDate secondLocalDate = secondLocalDateTime.toLocalDate();
    LocalTime secondLocalTime = secondLocalDateTime.toLocalTime();

    /*Calculate the time difference*/
    Duration duration = Duration.between(firstLocalDateTime, secondLocalDateTime);
    long durationDays = duration.toDays();
    Duration throughoutTheDayDuration = duration.minusDays(durationDays);
    Logger.getLogger(PeriodDuration.class.getName()).log(Level.INFO,
            "Duration is: " + duration + " this is " + durationDays
            + " days and " + throughoutTheDayDuration + " time.");

    Period period = Period.between(firstLocalDate, secondLocalDate);

    /*Correct the date difference*/
    if (secondLocalTime.isBefore(firstLocalTime)) {
        period = period.minusDays(1);
        Logger.getLogger(PeriodDuration.class.getName()).log(Level.INFO,
                "minus 1 day");
    }

    Logger.getLogger(PeriodDuration.class.getName()).log(Level.INFO,
            "Period between " + firstLocalDateTime + " and "
            + secondLocalDateTime + " is: " + period + " and duration is: "
            + throughoutTheDayDuration
            + "\n-----------------------------------------------------------------");

    /*Calculate chrono unit values and  write it in array*/
    chronoUnits[0] = period.getYears();
    chronoUnits[1] = period.getMonths();
    chronoUnits[2] = period.getDays();
    chronoUnits[3] = throughoutTheDayDuration.toHours();
    chronoUnits[4] = throughoutTheDayDuration.toMinutes() % 60;
    chronoUnits[5] = throughoutTheDayDuration.getSeconds() % 60;
}

Metode di atas dapat digunakan untuk menghitung selisih nilai tanggal dan waktu setempat, misalnya:

public long[] getChronoUnits(String firstLocalDateTimeString, String secondLocalDateTimeString) {
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    LocalDateTime firstLocalDateTime = LocalDateTime.parse(firstLocalDateTimeString, formatter);
    LocalDateTime secondLocalDateTime = LocalDateTime.parse(secondLocalDateTimeString, formatter);

    long[] chronoUnits = new long[6];
    if (secondLocalDateTime.isAfter(firstLocalDateTime)) {
        getChronoUnitForSecondAfterFirst(firstLocalDateTime, secondLocalDateTime, chronoUnits);
    } else {
        getChronoUnitForSecondAfterFirst(secondLocalDateTime, firstLocalDateTime, chronoUnits);
    }
    return chronoUnits;
}

Lebih mudah menulis unit test untuk metode di atas (keduanya adalah anggota kelas PeriodDuration). Ini kodenya:

@RunWith(Parameterized.class)
public class PeriodDurationTest {

private final String firstLocalDateTimeString;
private final String secondLocalDateTimeString;
private final long[] chronoUnits;

public PeriodDurationTest(String firstLocalDateTimeString, String secondLocalDateTimeString, long[] chronoUnits) {
    this.firstLocalDateTimeString = firstLocalDateTimeString;
    this.secondLocalDateTimeString = secondLocalDateTimeString;
    this.chronoUnits = chronoUnits;
}

@Parameters
public static Collection<Object[]> periodValues() {
    long[] chronoUnits0 = {0, 0, 0, 0, 0, 0};
    long[] chronoUnits1 = {0, 0, 0, 1, 0, 0};
    long[] chronoUnits2 = {0, 0, 0, 23, 0, 0};
    long[] chronoUnits3 = {0, 0, 0, 1, 0, 0};
    long[] chronoUnits4 = {0, 0, 0, 23, 0, 0};
    long[] chronoUnits5 = {0, 0, 1, 23, 0, 0};
    long[] chronoUnits6 = {29, 8, 24, 12, 0, 50};
    long[] chronoUnits7 = {29, 8, 24, 12, 0, 50};
    return Arrays.asList(new Object[][]{
        {"2015-09-09 21:46:44", "2015-09-09 21:46:44", chronoUnits0},
        {"2015-09-09 21:46:44", "2015-09-09 22:46:44", chronoUnits1},
        {"2015-09-09 21:46:44", "2015-09-10 20:46:44", chronoUnits2},
        {"2015-09-09 21:46:44", "2015-09-09 20:46:44", chronoUnits3},
        {"2015-09-10 20:46:44", "2015-09-09 21:46:44", chronoUnits4},
        {"2015-09-11 20:46:44", "2015-09-09 21:46:44", chronoUnits5},
        {"1984-12-16 07:45:55", "2014-09-09 19:46:45", chronoUnits6},
        {"2014-09-09 19:46:45", "1984-12-16 07:45:55", chronoUnits6}
    });
}

@Test
public void testGetChronoUnits() {
    PeriodDuration instance = new PeriodDuration();
    long[] expResult = this.chronoUnits;
    long[] result = instance.getChronoUnits(this.firstLocalDateTimeString, this.secondLocalDateTimeString);
    assertArrayEquals(expResult, result);
}

}

Semua tes berhasil apakah nilai LocalDateTime pertama adalah sebelum dan untuk nilai-nilai LocalTime.

Dan versi @Thomas di Groovy dengan mengambil unit yang diinginkan dalam daftar alih-alih nilai hardcoding. Implementasi ini (yang dapat dengan mudah porting ke Java - saya membuat deklarasi fungsi eksplisit) membuat pendekatan Thomas lebih dapat digunakan kembali.

def fromDateTime = LocalDateTime.of(1968, 6, 14, 0, 13, 0)
def toDateTime = LocalDateTime.now()
def listOfUnits = [
    ChronoUnit.YEARS, ChronoUnit.MONTHS, ChronoUnit.DAYS,
    ChronoUnit.HOURS, ChronoUnit.MINUTES, ChronoUnit.SECONDS,
    ChronoUnit.MILLIS]

println calcDurationInTextualForm(listOfUnits, fromDateTime, toDateTime)    

String calcDurationInTextualForm(List<ChronoUnit> listOfUnits, LocalDateTime ts, LocalDateTime to)
{
    def result = []

    listOfUnits.each { chronoUnit ->
        long amount = ts.until(to, chronoUnit)
        ts = ts.plus(amount, chronoUnit)

        if (amount) {
            result << "$amount ${chronoUnit.toString()}"
        }
    }

    result.join(', ')
}

Pada saat penulisan ini, kode di atas kembali 47 Years, 8 Months, 9 Days, 22 Hours, 52 Minutes, 7 Seconds, 140 Millis. Dan, untuk input @Gennady Kolomoets, kode kembali 23 Hours.

Ketika Anda memberikan daftar unit, itu harus diurutkan berdasarkan ukuran unit (terbesar pertama):

def listOfUnits = [ChronoUnit.WEEKS, ChronoUnit.DAYS, ChronoUnit.HOURS]
// returns 2495 Weeks, 3 Days, 8 Hours

Inilah jawaban yang sangat sederhana untuk pertanyaan Anda. Berhasil.

import java.time.*;
import java.util.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;

public class MyClass {
public static void main(String args[]) {
    DateTimeFormatter T = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm");
    Scanner h = new Scanner(System.in);

    System.out.print("Enter date of birth[dd/mm/yyyy hh:mm]: ");
    String b = h.nextLine();

    LocalDateTime bd = LocalDateTime.parse(b,T);
    LocalDateTime cd = LocalDateTime.now();

    long minutes = ChronoUnit.MINUTES.between(bd, cd);
    long hours = ChronoUnit.HOURS.between(bd, cd);

    System.out.print("Age is: "+hours+ " hours, or " +minutes+ " minutes old");
}
}

Joda-Time

Karena banyak jawaban yang diperlukan dukungan API 26 dan API min saya adalah 23, saya menyelesaikannya dengan kode di bawah ini:

import org.joda.time.Days

LocalDate startDate = Something
LocalDate endDate = Something
// The difference would be exclusive of both dates, 
// so in most of use cases we may need to increment it by 1
Days.daysBetween(startDate, endDate).days

Setelah lebih dari lima tahun saya menjawab pertanyaan saya. Saya pikir masalah dengan durasi negatif dapat diselesaikan dengan koreksi sederhana:

LocalDateTime fromDateTime = LocalDateTime.of(2014, 9, 9, 7, 46, 45);
LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 10, 6, 46, 45);

Period period = Period.between(fromDateTime.toLocalDate(), toDateTime.toLocalDate());
Duration duration = Duration.between(fromDateTime.toLocalTime(), toDateTime.toLocalTime());

if (duration.isNegative()) {
    period = period.minusDays(1);
    duration = duration.plusDays(1);
}
long seconds = duration.getSeconds();
long hours = seconds / SECONDS_PER_HOUR;
long minutes = ((seconds % SECONDS_PER_HOUR) / SECONDS_PER_MINUTE);
long secs = (seconds % SECONDS_PER_MINUTE);
long time[] = {hours, minutes, secs};
System.out.println(period.getYears() + " years "
            + period.getMonths() + " months "
            + period.getDays() + " days "
            + time[0] + " hours "
            + time[1] + " minutes "
            + time[2] + " seconds.");

Catatan: Situs https://www.epochconverter.com/date-difference sekarang menghitung perbedaan waktu dengan benar.

Terima kasih atas diskusi dan saran Anda.