Hoe krijg ik het verschil tussen twee datums in Android?, heb alles geprobeerd en post

Ik heb alle berichten hier gezien en ik weet nog steeds niet hoe ik het verschil kan maken tussen twee Android-datums.

Dit is wat ik doe:

long diff = date1.getTime() - date2.getTime();
Date diffDate = new Date(diff);

en ik krijg: de datum is 1 januari 1970 en de tijd is altijd groter in twee uur… Ik kom uit Israël, dus de twee uur is timeOffset.

Hoe kan ik een normaal verschil krijgen???

Antwoord 1, autoriteit 100%

Je bent dicht bij het juiste antwoord, je krijgt het verschil in milliseconden tussen die twee datums, maar als je probeert een datum te construeren uit dat verschil, gaat het er vanuit dat je een nieuwe Dateobject met die verschilwaarde als epochetijd. Als je op zoek bent naar een tijd in uren, dan moet je gewoon wat basisberekeningen doen op die diffom de verschillende tijdsdelen te krijgen.

Java:

long diff = date1.getTime() - date2.getTime();
long seconds = diff / 1000;
long minutes = seconds / 60;
long hours = minutes / 60;
long days = hours / 24;

Kotlin:

val diff: Long = date1.getTime() - date2.getTime()
val seconds = diff / 1000
val minutes = seconds / 60
val hours = minutes / 60
val days = hours / 24

Al deze wiskunde voert gewoon gehele getallen uit, dus alle decimale punten worden afgekapt

Antwoord 2, autoriteit 40%

   long diffInMillisec = date1.getTime() - date2.getTime();
    long diffInDays = TimeUnit.MILLISECONDS.toDays(diffInMillisec);
    long diffInHours = TimeUnit.MILLISECONDS.toHours(diffInMillisec);
    long diffInMin = TimeUnit.MILLISECONDS.toMinutes(diffInMillisec);
    long diffInSec = TimeUnit.MILLISECONDS.toSeconds(diffInMillisec);

Antwoord 3, autoriteit 16%

Enige toevoeging:
Hier converteer ik string naar datum en vergelijk ik de huidige tijd.

String toyBornTime = "2014-06-18 12:56:50";
    SimpleDateFormat dateFormat = new SimpleDateFormat(
            "yyyy-MM-dd HH:mm:ss");
    try {
        Date oldDate = dateFormat.parse(toyBornTime);
        System.out.println(oldDate);
        Date currentDate = new Date();
        long diff = currentDate.getTime() - oldDate.getTime();
        long seconds = diff / 1000;
        long minutes = seconds / 60;
        long hours = minutes / 60;
        long days = hours / 24;
        if (oldDate.before(currentDate)) {
            Log.e("oldDate", "is previous date");
            Log.e("Difference: ", " seconds: " + seconds + " minutes: " + minutes
                    + " hours: " + hours + " days: " + days);
        }
        // Log.e("toyBornTime", "" + toyBornTime);
    } catch (ParseException e) {
        e.printStackTrace();
    }

Antwoord 4, autoriteit 7%

java.time.Duration

Gebruik java.time.Duration:

   Duration diff = Duration.between(instant2, instant1);
    System.out.println(diff);

Hiermee wordt iets afgedrukt als

PT109H27M21S

Dit betekent een tijdsperiode van 109 uur 27 minuten 21 seconden. Als je iets meer voor mensen leesbaar wilt hebben – ik zal eerst de Java 9-versie geven, het is het eenvoudigst:

   String formattedDiff = String.format(Locale.ENGLISH,
            "%d days %d hours %d minutes %d seconds",
            diff.toDays(), diff.toHoursPart(), diff.toMinutesPart(), diff.toSecondsPart());
    System.out.println(formattedDiff);

Nu krijgen we

4 days 13 hours 27 minutes 21 seconds

De klasse Durationmaakt deel uit van java.timede moderne Java-datum- en tijd-API. Dit is gebundeld op nieuwere Android-apparaten. Op oudere apparaten, download ThreeTenABP en voeg het toe aan uw project, en zorg ervoor dat u org.threeten.bp.Durationen andere datum-tijdklassen die u mogelijk nodig heeft uit hetzelfde pakket importeert.

Ervan uitgaande dat u de Java 9-versie nog steeds niet hebt, kunt u de grotere eenheden om de beurt aftrekken om de kleinere te krijgen:

   long days = diff.toDays();
    diff = diff.minusDays(days);
    long hours = diff.toHours();
    diff = diff.minusHours(hours);
    long minutes = diff.toMinutes();
    diff = diff.minusMinutes(minutes);
    long seconds = diff.toSeconds();

Vervolgens kunt u de vier variabelen opmaken zoals hierboven.

Wat heb je verkeerd gedaan?

Een Datestaat voor een tijdstip. Het was nooit bedoeld om een ​​hoeveelheid tijd, een duur weer te geven, en het is er ook niet geschikt voor. Proberen om dat te laten werken zou op zijn bestleiden tot verwarrende en moeilijk te onderhouden code. Dat wil je niet, dus doe het alsjeblieft niet.

Vraag: vereist java.time geen Android API-niveau 26?

java.time werkt goed op zowel oudere als nieuwere Android-apparaten. Het vereist slechts ten minste Java 6.

• In Java 8 en hoger en op nieuwere Android-apparaten (vanaf API-niveau 26) is de moderne API ingebouwd.
• In niet-Android Java 6 en 7 krijg je de ThreeTen Backport, de backport van de moderne klassen (ThreeTen voor JSR 310; zie de links onderaan).
• Gebruik op (oudere) Android de Android-editie van ThreeTen Backport. Het heet ThreeTenABP. En zorg ervoor dat u de datum- en tijdklassen importeert uit org.threeten.bpmet subpakketten.

Links

• Oracle-tutorial: Datum Tijd, waarin wordt uitgelegd hoe u java.time.
• ThreeTen Backport-project, de backport van java.timenaar Java 6 en 7
• ThreeTenABP, Android-editie van ThreeTen Backport
• Vraag: hoe ThreeTenABP te gebruiken in Android Project, met een zeer grondige uitleg.
• Java Specificatieverzoek (JSR) 310.

Antwoord 5, autoriteit 3%

Hoe zit het met het gebruik van Instant:

val instant1 = now()
val instant2 = now()
val diff: Duration = Duration.between(instant1, instant2)
val minutes = diff.toMinutes()

Je kunt je Instant zelfs opslaan met instant1.toString() en die string ontleden met parse(string).

Als u Android API-niveau < 26 gewoon toevoegen
Ondersteuning voor desugaring van Java 8+ API
aan uw project.

Antwoord 6, autoriteit 2%

Als je Kotlin-taal gebruikt voor Android-ontwikkeling, kun je in dagen als deze verschil krijgen:

fun daysDiff(c1: Calendar, c2: Calendar): Long {
    val diffInMillis = c1.timeInMillis - c2.timeInMillis
    return diffInMillis.milliseconds.inWholeDays
}

of als u resultaten in een ander type wilt krijgen, kunt u inWholeDaysvervangen door toInt(...), toDouble(...), toString(...).

Als het enige datumverschil waarin u geïnteresseerd bent dagen is (laten we zeggen als een resultaat van het dubbele type), kunt u een methode voor operatorextensie als volgt maken:

operator fun Calendar.minus(c: Calendar): Double {
    val diffInMillis = timeInMillis - c.timeInMillis
    return diffInMillis.milliseconds.toDouble(DurationUnit.DAYS)
}

En dan zal elke bewerking zoals calendar2 - calendar1het verschil in dagen als Double teruggeven.

Antwoord 7

Hier is mijn antwoord gebaseerd op het antwoord van @Ole V.V..

Dit werkt ook met Singular.

private String getDuration(Date d1, Date d2) {
    Duration diff = Duration.between(d1.toInstant(), d2.toInstant());
    long days = diff.toDays();
    diff = diff.minusDays(days);
    long hours = diff.toHours();
    diff = diff.minusHours(hours);
    long minutes = diff.toMinutes();
    diff = diff.minusMinutes(minutes);
    long seconds = diff.toMillis();
    StringBuilder formattedDiff = new StringBuilder();
    if(days!=0){
        if(days==1){
            formattedDiff.append(days + " Day ");
        }else {
            formattedDiff.append(days + " Days ");
        }
    }if(hours!=0){
        if(hours==1){
            formattedDiff.append(hours + " hour ");
        }else{
            formattedDiff.append(hours + " hours ");
        }
    }if(minutes!=0){
        if(minutes==1){
            formattedDiff.append(minutes + " minute ");
        }else{
            formattedDiff.append(minutes + " minutes ");
        }
    }if(seconds!=0){
        if(seconds==1){
            formattedDiff.append(seconds + " second ");
        }else{
            formattedDiff.append(seconds + " seconds ");
        }
    }
    return formattedDiff.toString();
}

Het werkt met een StringBuilder om alles bij elkaar te voegen.

Antwoord 8

Ik heb deze methode geprobeerd..maar weet niet waarom ik geen goed resultaat krijg

long diff = date1.getTime() - date2.getTime();
long seconds = diff / 1000;
long minutes = seconds / 60;
long hours = minutes / 60;
long days = hours / 24;

Maar dit werkt

long miliSeconds = date1.getTime() -date2.getTime();
long seconds = TimeUnit.MILLISECONDS.toSeconds(miliSeconds);
long minute = seconds/60;
long hour = minute/60;
long days = hour/24;

Antwoord 9

Georgische kalender gebruiken

public void dateDifferenceExample() {
        // Set the date for both of the calendar instance
        GregorianCalendar calDate = new GregorianCalendar(2012, 10, 02,5,23,43);
        GregorianCalendar cal2 = new GregorianCalendar(2015, 04, 02);
        // Get the represented date in milliseconds
        long millis1 = calDate.getTimeInMillis();
        long millis2 = cal2.getTimeInMillis();
        // Calculate difference in milliseconds
        long diff = millis2 - millis1;
        // Calculate difference in seconds
        long diffSeconds = diff / 1000;
        // Calculate difference in minutes
        long diffMinutes = diff / (60 * 1000);
        // Calculate difference in hours
        long diffHours = diff / (60 * 60 * 1000);
        // Calculate difference in days
        long diffDays = diff / (24 * 60 * 60 * 1000);
    Toast.makeText(getContext(), ""+diffSeconds, Toast.LENGTH_SHORT).show();
}

Antwoord 10

Gebruik deze functies

   public static int getDateDifference(
        int previousYear, int previousMonthOfYear, int previousDayOfMonth,
        int nextYear, int nextMonthOfYear, int nextDayOfMonth,
        int differenceToCount){
    // int differenceToCount = can be any of the following
    //  Calendar.MILLISECOND;
    //  Calendar.SECOND;
    //  Calendar.MINUTE;
    //  Calendar.HOUR;
    //  Calendar.DAY_OF_MONTH;
    //  Calendar.MONTH;
    //  Calendar.YEAR;
    //  Calendar.----
    Calendar previousDate = Calendar.getInstance();
    previousDate.set(Calendar.DAY_OF_MONTH, previousDayOfMonth);
    // month is zero indexed so month should be minus 1
    previousDate.set(Calendar.MONTH, previousMonthOfYear);
    previousDate.set(Calendar.YEAR, previousYear);
    Calendar nextDate = Calendar.getInstance();
    nextDate.set(Calendar.DAY_OF_MONTH, previousDayOfMonth);
    // month is zero indexed so month should be minus 1
    nextDate.set(Calendar.MONTH, previousMonthOfYear);
    nextDate.set(Calendar.YEAR, previousYear);
    return getDateDifference(previousDate,nextDate,differenceToCount);
}
public static int getDateDifference(Calendar previousDate,Calendar nextDate,int differenceToCount){
    // int differenceToCount = can be any of the following
    //  Calendar.MILLISECOND;
    //  Calendar.SECOND;
    //  Calendar.MINUTE;
    //  Calendar.HOUR;
    //  Calendar.DAY_OF_MONTH;
    //  Calendar.MONTH;
    //  Calendar.YEAR;
    //  Calendar.----
    //raise an exception if previous is greater than nextdate.
    if(previousDate.compareTo(nextDate)>0){
        throw new RuntimeException("Previous Date is later than Nextdate");
    }
    int difference=0;
    while(previousDate.compareTo(nextDate)<=0){
        difference++;
        previousDate.add(differenceToCount,1);
    }
    return difference;
}

Antwoord 11

geschreven in Kotlin:
als je een verschil tussen 2 datums nodig hebt en niet om de datums zelf geeft (goed als je iets in de app moet doen, op basis van tijd van andere bewerkingstijd die bijvoorbeeld is opgeslagen in gedeelde voorkeuren).
eerste keer opslaan :

val firstTime:Long= System.currentTimeMillis()

tweede keer opslaan:

val now:Long= System.currentTimeMillis()

bereken de milliseconden tussen 2 keer:

val milisecondsSinceLastTime: Long =(now-lastScrollTime)

Antwoord 12

Tijdsverschil tussen AM en PM bekijken

private void getTimeDiff(){
    SimpleDateFormat sdf = new SimpleDateFormat("hh:mm:ss aa");
    Date systemDate = Calendar.getInstance().getTime();
    String myDate = sdf.format(systemDate);
    Date current = null;
    Date Date2 = null;
    try {
        current = sdf.parse(myDate);
        Date2 = sdf.parse("12:00:00 am");
    } catch (ParseException e) {
        e.printStackTrace();
    }
    long millse = Date2.getTime() - current.getTime();
    long mills = Math.abs(millse);
    int Hours = (int) (mills/(1000 * 60 * 60));
    int Mins = (int) (mills/(1000*60)) % 60;
    long Secs = (int) (mills / 1000) % 60;
    String diff = Hours + ":" + Mins + ":" + Secs; 
    if(Hours>=12){
        String requiredTime = 24-Hours + ":" + Mins + ":" + Secs; 
        Log.d("TAG",requiredTime);
    }else{
        int time =  12 - Hours;
        String requiredTime = time + ":" + Mins + ":" + Secs;
        Log.d("TAG",requiredTime);
    }
}

Antwoord 13

wanneer u probeert een datum te construeren uit dat verschil, wordt ervan uitgegaan dat u een nieuw Date-object wilt maken met die verschilwaarde als epochetijd.

//get time in milliseconds
long diff = date1.getTime() - date2.getTime();
//get time in seconds
long seconds = diff / 1000;
//and so on
long minutes = seconds / 60;
long hours = minutes / 60;
long days = hours / 24;

voor meer informatie kunt u deze links gebruiken:

Oracle-tutorial: Datum Tijd, waarin wordt uitgelegd hoe u java.time gebruikt.

ThreeTen Backport-project, de backport van java.time naar Java
6 en 7.

ThreeTenABP, Android-editie van ThreeTen Backport.

Vraag: Hoe ThreeTenABP te gebruiken in Android Project, met een zeer grondige uitleg.

Antwoord 14

kortste antwoord dat voor mij werkt. stuur start- en einddatum in milliseconden.

public int GetDifference(long start,long end){
    Calendar cal = Calendar.getInstance();
    cal.setTimeInMillis(start);
    int hour = cal.get(Calendar.HOUR_OF_DAY);
    int min = cal.get(Calendar.MINUTE);
    long t=(23-hour)*3600000+(59-min)*60000;
    t=start+t;
    int diff=0;
    if(end>t){
        diff=(int)((end-t)/ TimeUnit.DAYS.toMillis(1))+1;
    }
    return  diff;
}