Come calcolare “tempo fa” in Java?

In Ruby on Rails, c’è una funzionalità che ti permette di prendere qualsiasi Data e stampare quanto “tempo fa” era.

Per esempio:

8 minutes ago 8 hours ago 8 days ago 8 months ago 8 years ago 

C’è un modo semplice per farlo in Java?

Dai un’occhiata alla libreria di PrettyTime .

È abbastanza semplice da usare:

 import org.ocpsoft.prettytime.PrettyTime; PrettyTime p = new PrettyTime(); System.out.println(p.format(new Date())); // prints "moments ago" 

Puoi anche passare una localizzazione per i messaggi internazionalizzati:

 PrettyTime p = new PrettyTime(new Locale("fr")); System.out.println(p.format(new Date())); // prints "à l'instant" 

Come notato nei commenti, Android ha questa funzionalità integrata nella class android.text.format.DateUtils .

Hai considerato l’enum TimeUnit ? Può essere piuttosto utile per questo genere di cose

  try { SimpleDateFormat format = new SimpleDateFormat("dd/MM/yyyy"); Date past = format.parse("01/10/2010"); Date now = new Date(); System.out.println(TimeUnit.MILLISECONDS.toMillis(now.getTime() - past.getTime()) + " milliseconds ago"); System.out.println(TimeUnit.MILLISECONDS.toMinutes(now.getTime() - past.getTime()) + " minutes ago"); System.out.println(TimeUnit.MILLISECONDS.toHours(now.getTime() - past.getTime()) + " hours ago"); System.out.println(TimeUnit.MILLISECONDS.toDays(now.getTime() - past.getTime()) + " days ago"); } catch (Exception j){ j.printStackTrace(); } 
  public class TimeUtils { public final static long ONE_SECOND = 1000; public final static long SECONDS = 60; public final static long ONE_MINUTE = ONE_SECOND * 60; public final static long MINUTES = 60; public final static long ONE_HOUR = ONE_MINUTE * 60; public final static long HOURS = 24; public final static long ONE_DAY = ONE_HOUR * 24; private TimeUtils() { } /** * converts time (in milliseconds) to human-readable format * " days,  hours,  minutes and (z) seconds" */ public static String millisToLongDHMS(long duration) { StringBuffer res = new StringBuffer(); long temp = 0; if (duration >= ONE_SECOND) { temp = duration / ONE_DAY; if (temp > 0) { duration -= temp * ONE_DAY; res.append(temp).append(" day").append(temp > 1 ? "s" : "") .append(duration >= ONE_MINUTE ? ", " : ""); } temp = duration / ONE_HOUR; if (temp > 0) { duration -= temp * ONE_HOUR; res.append(temp).append(" hour").append(temp > 1 ? "s" : "") .append(duration >= ONE_MINUTE ? ", " : ""); } temp = duration / ONE_MINUTE; if (temp > 0) { duration -= temp * ONE_MINUTE; res.append(temp).append(" minute").append(temp > 1 ? "s" : ""); } if (!res.toString().equals("") && duration >= ONE_SECOND) { res.append(" and "); } temp = duration / ONE_SECOND; if (temp > 0) { res.append(temp).append(" second").append(temp > 1 ? "s" : ""); } return res.toString(); } else { return "0 second"; } } public static void main(String args[]) { System.out.println(millisToLongDHMS(123)); System.out.println(millisToLongDHMS((5 * ONE_SECOND) + 123)); System.out.println(millisToLongDHMS(ONE_DAY + ONE_HOUR)); System.out.println(millisToLongDHMS(ONE_DAY + 2 * ONE_SECOND)); System.out.println(millisToLongDHMS(ONE_DAY + ONE_HOUR + (2 * ONE_MINUTE))); System.out.println(millisToLongDHMS((4 * ONE_DAY) + (3 * ONE_HOUR) + (2 * ONE_MINUTE) + ONE_SECOND)); System.out.println(millisToLongDHMS((5 * ONE_DAY) + (4 * ONE_HOUR) + ONE_MINUTE + (23 * ONE_SECOND) + 123)); System.out.println(millisToLongDHMS(42 * ONE_DAY)); /* output : 0 second 5 seconds 1 day, 1 hour 1 day and 2 seconds 1 day, 1 hour, 2 minutes 4 days, 3 hours, 2 minutes and 1 second 5 days, 4 hours, 1 minute and 23 seconds 42 days */ } } 

more @ Formatta una durata in millisecondi in un formato leggibile

Prendo le risposte RealHowTo e Ben J e creo la mia versione:

 public class TimeAgo { public static final List times = Arrays.asList( TimeUnit.DAYS.toMillis(365), TimeUnit.DAYS.toMillis(30), TimeUnit.DAYS.toMillis(1), TimeUnit.HOURS.toMillis(1), TimeUnit.MINUTES.toMillis(1), TimeUnit.SECONDS.toMillis(1) ); public static final List timesString = Arrays.asList("year","month","day","hour","minute","second"); public static String toDuration(long duration) { StringBuffer res = new StringBuffer(); for(int i=0;i< TimeAgo.times.size(); i++) { Long current = TimeAgo.times.get(i); long temp = duration/current; if(temp>0) { res.append(temp).append(" ").append( TimeAgo.timesString.get(i) ).append(temp != 1 ? "s" : "").append(" ago"); break; } } if("".equals(res.toString())) return "0 seconds ago"; else return res.toString(); } public static void main(String args[]) { System.out.println(toDuration(123)); System.out.println(toDuration(1230)); System.out.println(toDuration(12300)); System.out.println(toDuration(123000)); System.out.println(toDuration(1230000)); System.out.println(toDuration(12300000)); System.out.println(toDuration(123000000)); System.out.println(toDuration(1230000000)); System.out.println(toDuration(12300000000L)); System.out.println(toDuration(123000000000L)); }} 

che stamperà quanto segue

 0 second ago 1 second ago 12 seconds ago 2 minutes ago 20 minutes ago 3 hours ago 1 day ago 14 days ago 4 months ago 3 years ago 

Questo si basa sulla risposta di RealHowTo quindi se ti piace, dagli anche un po ‘di amore.

Questa versione ripulita consente di specificare l’intervallo di tempo che potrebbe essere interessato.

Gestisce anche la parte “e” in modo leggermente diverso. Trovo spesso che quando si uniscono stringhe con un delimitatore è più facile saltare la logica complicata e basta eliminare l’ultimo delimitatore quando hai finito.

 import java.util.concurrent.TimeUnit; import static java.util.concurrent.TimeUnit.MILLISECONDS; public class TimeUtils { /** * Converts time to a human readable format within the specified range * * @param duration the time in milliseconds to be converted * @param max the highest time unit of interest * @param min the lowest time unit of interest */ public static String formatMillis(long duration, TimeUnit max, TimeUnit min) { StringBuilder res = new StringBuilder(); TimeUnit current = max; while (duration > 0) { long temp = current.convert(duration, MILLISECONDS); if (temp > 0) { duration -= current.toMillis(temp); res.append(temp).append(" ").append(current.name().toLowerCase()); if (temp < 2) res.deleteCharAt(res.length() - 1); res.append(", "); } if (current == min) break; current = TimeUnit.values()[current.ordinal() - 1]; } // clean up our formatting.... // we never got a hit, the time is lower than we care about if (res.lastIndexOf(", ") < 0) return "0 " + min.name().toLowerCase(); // yank trailing ", " res.deleteCharAt(res.length() - 2); // convert last ", " to " and" int i = res.lastIndexOf(", "); if (i > 0) { res.deleteCharAt(i); res.insert(i, " and"); } return res.toString(); } } 

Piccolo codice per dargli un vortice:

 import static java.util.concurrent.TimeUnit.*; public class Main { public static void main(String args[]) { long[] durations = new long[]{ 123, SECONDS.toMillis(5) + 123, DAYS.toMillis(1) + HOURS.toMillis(1), DAYS.toMillis(1) + SECONDS.toMillis(2), DAYS.toMillis(1) + HOURS.toMillis(1) + MINUTES.toMillis(2), DAYS.toMillis(4) + HOURS.toMillis(3) + MINUTES.toMillis(2) + SECONDS.toMillis(1), DAYS.toMillis(5) + HOURS.toMillis(4) + MINUTES.toMillis(1) + SECONDS.toMillis(23) + 123, DAYS.toMillis(42) }; for (long duration : durations) { System.out.println(TimeUtils.formatMillis(duration, DAYS, SECONDS)); } System.out.println("\nAgain in only hours and minutes\n"); for (long duration : durations) { System.out.println(TimeUtils.formatMillis(duration, HOURS, MINUTES)); } } } 

Quale emetterà il seguente:

 0 seconds 5 seconds 1 day and 1 hour 1 day and 2 seconds 1 day, 1 hour and 2 minutes 4 days, 3 hours, 2 minutes and 1 second 5 days, 4 hours, 1 minute and 23 seconds 42 days Again in only hours and minutes 0 minutes 0 minutes 25 hours 24 hours 25 hours and 2 minutes 99 hours and 2 minutes 124 hours and 1 minute 1008 hours 

E nel caso qualcuno ne abbia mai bisogno, ecco una class che convertirà qualsiasi stringa come quella precedente in millisecondi . È piuttosto utile per consentire alle persone di specificare timeout di varie cose in testo leggibile.

c’è un modo semplice per farlo:

diciamo che vuoi il tempo 20 minuti fa:

 Long minutesAgo = new Long(20); Date date = new Date(); Date dateIn_X_MinAgo = new Date (date.getTime() - minutesAgo*60*1000); 

questo è tutto..

java.time

Utilizzo del framework java.time incorporato in Java 8 e versioni successive.

 LocalDateTime t1 = LocalDateTime.of(2015, 1, 1, 0, 0, 0); LocalDateTime t2 = LocalDateTime.now(); Period period = Period.between(t1.toLocalDate(), t2.toLocalDate()); Duration duration = Duration.between(t1, t2); System.out.println("First January 2015 is " + period.getYears() + " years ago"); System.out.println("First January 2015 is " + period.getMonths() + " months ago"); System.out.println("First January 2015 is " + period.getDays() + " days ago"); System.out.println("First January 2015 is " + duration.toHours() + " hours ago"); System.out.println("First January 2015 is " + duration.toMinutes() + " minutes ago"); 

Se stai cercando un semplice “Oggi”, “Ieri” o “x giorni fa”.

 private String getDaysAgo(Date date){ long days = (new Date().getTime() - date.getTime()) / 86400000; if(days == 0) return "Today"; else if(days == 1) return "Yesterday"; else return days + " days ago"; } 

Informazioni sulle soluzioni integrate:

Java non ha alcun supporto integrato per la formattazione dei tempi relativi, anche non Java-8 e il suo nuovo pacchetto java.time . Se hai solo bisogno di inglese e nient’altro allora e solo allora una soluzione fatta a mano potrebbe essere accettabile – vedi la risposta di @RealHowTo (anche se ha il forte svantaggio di non tenere conto del fuso orario per la traduzione dei delta istantanei in ora locale unità!). In ogni caso, se si desidera evitare soluzioni alternative complesse sviluppate in casa, in particolare per altre impostazioni locali, è necessaria una libreria esterna.

In quest’ultimo caso, consiglio di utilizzare la mia libreria Time4J (o Time4A su Android). Offre la massima flessibilità e la maggior parte della potenza i18n . La class net.time4j.PrettyTime ha sette metodi printRelativeTime...(...) per questo scopo. Esempio utilizzando un orologio di prova come sorgente del tempo:

 TimeSource clock = () -> PlainTimestamp.of(2015, 8, 1, 10, 24, 5).atUTC(); Moment moment = PlainTimestamp.of(2015, 8, 1, 17, 0).atUTC(); // our input String durationInDays = PrettyTime.of(Locale.GERMAN).withReferenceClock(clock).printRelative( moment, Timezone.of(EUROPE.BERLIN), TimeUnit.DAYS); // controlling the precision System.out.println(durationInDays); // heute (german word for today) 

Un altro esempio che utilizza java.time.Instant come input:

 String relativeTime = PrettyTime.of(Locale.ENGLISH) .printRelativeInStdTimezone(Moment.from(Instant.EPOCH)); System.out.println(relativeTime); // 45 years ago 

Questa libreria supporta l’ultima versione (v4.17) 80 lingue e anche alcune localizzazioni specifiche per paese (in particolare per spagnolo, inglese, arabo, francese). I dati i18n si basano principalmente sulla nuovissima versione VDR di CLDR . Altri motivi importanti per cui utilizzare questa libreria sono il buon supporto per le regole plurali (che sono spesso diverse dall’inglese in altre lingue), lo stile del formato abbreviato (ad esempio: “1 secondo fa”) e i modi espressivi per tenere conto dei fusi orari . Time4J è anche a conoscenza di dettagli esotici come il salto di secondi nei calcoli dei tempi relativi (non molto importante ma forma un messaggio relativo all’orizzonte di aspettativa). La compatibilità con Java-8 esiste grazie a metodi di conversione facilmente disponibili per tipi come java.time.Instant o java.time.Period .

Ci sono degli svantaggi? Solo due.

  • La libreria non è piccola (anche per il suo grande archivio i18n-data).
  • L’API non è ben nota quindi la conoscenza e il supporto della comunità non sono ancora disponibili, altrimenti la documentazione fornita è abbastanza dettagliata e completa.

(Compatto) alternative:

Se cerchi una soluzione più piccola e non hai bisogno di così tante funzioni e sei disposta a tollerare possibili problemi di qualità relativi ai dati i18n, allora:

  • Vorrei raccomandare ocpsoft / PrettyTime (supporto per 32 lingue effettivamente (presto 34?) Adatto per lavorare solo con java.util.Date – vedere la risposta di @ataylor). Lo standard industriale CLDR (dal consorzio Unicode) con il suo grande background di comunità non è, purtroppo, una base dei dati i18n, quindi ulteriori miglioramenti o miglioramenti dei dati possono richiedere del tempo …

  • Se sei su Android, la class helper android.text.format.DateUtils è un’alternativa integrata sottile (vedi altri commenti e risposte qui, con lo svantaggio di non avere supporto per anni e mesi e sono sicuro che solo pochissime persone come lo stile API di questa class helper.

  • Se sei un fan di Joda-Time allora puoi guardare la sua class PeriodFormat (supporto per 14 lingue nella release v2.9.4, dall’altra parte: Joda-Time non è sicuramente compatta, quindi lo cito qui solo per completezza). Questa libreria non è una vera risposta perché i tempi relativi non sono supportati affatto. Sarà necessario aggiungere il letterale “fa” almeno (e rimuovere manualmente tutte le unità inferiori dai formati di elenco generati – scomodo). A differenza di Time4J o Android-DateUtils, non ha alcun supporto speciale per le abbreviazioni o il passaggio automatico dai tempi relativi alle rappresentazioni del tempo assoluto. Come PrettyTime, è totalmente dipendente dai contributi non confermati dei membri privati ​​della comunità Java ai suoi dati i18n.

Ho creato una semplice porta Java timeago del plug-in jquery-timeago che fa ciò che stai chiedendo.

 TimeAgo time = new TimeAgo(); String minutes = time.timeAgo(System.currentTimeMillis() - (15*60*1000)); // returns "15 minutes ago" 

Il pacchetto joda-time , ha la nozione di Periodi . È ansible eseguire operazioni aritmetiche con Periodi e DateTimes.

Dai documenti :

 public boolean isRentalOverdue(DateTime datetimeRented) { Period rentalPeriod = new Period().withDays(2).withHours(12); return datetimeRented.plus(rentalPeriod).isBeforeNow(); } 

È ansible utilizzare questa funzione per calcolare il tempo fa

  private String timeAgo(long time_ago) { long cur_time = (Calendar.getInstance().getTimeInMillis()) / 1000; long time_elapsed = cur_time - time_ago; long seconds = time_elapsed; int minutes = Math.round(time_elapsed / 60); int hours = Math.round(time_elapsed / 3600); int days = Math.round(time_elapsed / 86400); int weeks = Math.round(time_elapsed / 604800); int months = Math.round(time_elapsed / 2600640); int years = Math.round(time_elapsed / 31207680); // Seconds if (seconds <= 60) { return "just now"; } //Minutes else if (minutes <= 60) { if (minutes == 1) { return "one minute ago"; } else { return minutes + " minutes ago"; } } //Hours else if (hours <= 24) { if (hours == 1) { return "an hour ago"; } else { return hours + " hrs ago"; } } //Days else if (days <= 7) { if (days == 1) { return "yesterday"; } else { return days + " days ago"; } } //Weeks else if (weeks <= 4.3) { if (weeks == 1) { return "a week ago"; } else { return weeks + " weeks ago"; } } //Months else if (months <= 12) { if (months == 1) { return "a month ago"; } else { return months + " months ago"; } } //Years else { if (years == 1) { return "one year ago"; } else { return years + " years ago"; } } } 

1) Qui time_ago è in microsecondo

Non è bello … ma il più vicino a cui riesco a pensare è usare Joda-Time (come descritto in questo post: come calcolare il tempo trascorso da ora con Joda Time?

Nel caso in cui si stia sviluppando un’app per Android, fornisce la class di utilità DateUtils per tutti questi requisiti. Dai un’occhiata al metodo di utilità DateUtils # getRelativeTimeSpanString () .

Dai documenti per

CharSequence getRelativeTimeSpanString (long time, long now, long minResolution)

Restituisce una stringa che descrive ‘tempo’ come un tempo relativo a ‘ora’. Gli intervalli di tempo passati sono formattati come “42 minuti fa”. Gli intervalli di tempo in futuro sono formattati come “In 42 minuti”.

timestamp tuo timestamp come ora e System.currentTimeMillis() come ora . minResolution consente di specificare il periodo minimo di tempo per la segnalazione.

Ad esempio, un tempo di 3 secondi nel passato verrà segnalato come “0 minuti fa” se è impostato su MINUTE_IN_MILLIS. Passa uno su 0, MINUTE_IN_MILLIS, HOUR_IN_MILLIS, DAY_IN_MILLIS, WEEK_IN_MILLIS ecc.

Questo è un codice migliore se consideriamo le prestazioni. Riduce il numero di calcoli. Motivo I minuti vengono calcolati solo se il numero di secondi è maggiore di 60 e le Ore vengono calcolate solo se il numero di minuti è maggiore di 60 e così via …

 class timeAgo { static String getTimeAgo(long time_ago) { time_ago=time_ago/1000; long cur_time = (Calendar.getInstance().getTimeInMillis())/1000 ; long time_elapsed = cur_time - time_ago; long seconds = time_elapsed; // Seconds if (seconds <= 60) { return "Just now"; } //Minutes else{ int minutes = Math.round(time_elapsed / 60); if (minutes <= 60) { if (minutes == 1) { return "a minute ago"; } else { return minutes + " minutes ago"; } } //Hours else { int hours = Math.round(time_elapsed / 3600); if (hours <= 24) { if (hours == 1) { return "An hour ago"; } else { return hours + " hrs ago"; } } //Days else { int days = Math.round(time_elapsed / 86400); if (days <= 7) { if (days == 1) { return "Yesterday"; } else { return days + " days ago"; } } //Weeks else { int weeks = Math.round(time_elapsed / 604800); if (weeks <= 4.3) { if (weeks == 1) { return "A week ago"; } else { return weeks + " weeks ago"; } } //Months else { int months = Math.round(time_elapsed / 2600640); if (months <= 12) { if (months == 1) { return "A month ago"; } else { return months + " months ago"; } } //Years else { int years = Math.round(time_elapsed / 31207680); if (years == 1) { return "One year ago"; } else { return years + " years ago"; } } } } } } } } } 

Dopo una lunga ricerca ho trovato questo.

  public class GetTimeLapse { public static String getlongtoago(long createdAt) { DateFormat userDateFormat = new SimpleDateFormat("E MMM dd HH:mm:ss Z yyyy"); DateFormat dateFormatNeeded = new SimpleDateFormat("MM/dd/yyyy HH:MM:SS"); Date date = null; date = new Date(createdAt); String crdate1 = dateFormatNeeded.format(date); // Date Calculation DateFormat dateFormat = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss"); crdate1 = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss").format(date); // get current date time with Calendar() Calendar cal = Calendar.getInstance(); String currenttime = dateFormat.format(cal.getTime()); Date CreatedAt = null; Date current = null; try { CreatedAt = dateFormat.parse(crdate1); current = dateFormat.parse(currenttime); } catch (java.text.ParseException e) { // TODO Auto-generated catch block e.printStackTrace(); } // Get msec from each, and subtract. long diff = current.getTime() - CreatedAt.getTime(); long diffSeconds = diff / 1000; long diffMinutes = diff / (60 * 1000) % 60; long diffHours = diff / (60 * 60 * 1000) % 24; long diffDays = diff / (24 * 60 * 60 * 1000); String time = null; if (diffDays > 0) { if (diffDays == 1) { time = diffDays + "day ago "; } else { time = diffDays + "days ago "; } } else { if (diffHours > 0) { if (diffHours == 1) { time = diffHours + "hr ago"; } else { time = diffHours + "hrs ago"; } } else { if (diffMinutes > 0) { if (diffMinutes == 1) { time = diffMinutes + "min ago"; } else { time = diffMinutes + "mins ago"; } } else { if (diffSeconds > 0) { time = diffSeconds + "secs ago"; } } } } return time; } } 

Per Android Esattamente come ha detto Ravi, ma dal momento che molte persone vogliono semplicemente copiare la cosa qui è.

  try { SimpleDateFormat formatter = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss Z"); Date dt = formatter.parse(date_from_server); CharSequence output = DateUtils.getRelativeTimeSpanString (dt.getTime()); your_textview.setText(output.toString()); } catch (Exception ex) { ex.printStackTrace(); your_textview.setText(""); } 

Spiegazione per le persone che hanno più tempo

  1. Ottieni i dati da qualche parte. Per prima cosa devi capire che è il formato.

Ex. Ottengo i dati da un server nel formato Wed, 27 Jan 2016 09:32:35 GMT [questo NON è probabilmente il tuo caso]

questo è tradotto in

SimpleDateFormat formatter = new SimpleDateFormat (“EEE, dd MMM yyyy HH: mm: ss Z”);

come faccio a saperlo? Leggi la documentazione qui.

Poi, dopo averlo analizzato, ho un appuntamento. quella data metto in getRelativeTimeSpanString (senza parametri aggiuntivi va bene per me, per essere predefinito a minuti)

Otterrai un’eccezione se non hai capito la stringa corretta dell’analisi , Qualcosa come: eccezione al carattere 5 . Guarda il carattere 5 e correggi la tua stringa di analisi iniziale. . Potresti ricevere un’altra eccezione, ripetere questa procedura finché non si ottiene la formula corretta.

Sulla base di un mucchio di risposte qui, ho creato il seguente esempio.

Esempio di utilizzo:

 String relativeDate = String.valueOf( TimeUtils.getRelativeTime( 1000L * myTimeInMillis() )); 

 import java.util.Arrays; import java.util.List; import static java.util.concurrent.TimeUnit.DAYS; import static java.util.concurrent.TimeUnit.HOURS; import static java.util.concurrent.TimeUnit.MINUTES; import static java.util.concurrent.TimeUnit.SECONDS; /** * Utilities for dealing with dates and times */ public class TimeUtils { public static final List times = Arrays.asList( DAYS.toMillis(365), DAYS.toMillis(30), DAYS.toMillis(7), DAYS.toMillis(1), HOURS.toMillis(1), MINUTES.toMillis(1), SECONDS.toMillis(1) ); public static final List timesString = Arrays.asList( "yr", "mo", "wk", "day", "hr", "min", "sec" ); /** * Get relative time ago for date * * NOTE: * if (duration > WEEK_IN_MILLIS) getRelativeTimeSpanString prints the date. * * ALT: * return getRelativeTimeSpanString(date, now, SECOND_IN_MILLIS, FORMAT_ABBREV_RELATIVE); * * @param date String.valueOf(TimeUtils.getRelativeTime(1000L * Date/Time in Millis) * @return relative time */ public static CharSequence getRelativeTime(final long date) { return toDuration( Math.abs(System.currentTimeMillis() - date) ); } private static String toDuration(long duration) { StringBuilder sb = new StringBuilder(); for(int i=0;i< times.size(); i++) { Long current = times.get(i); long temp = duration / current; if (temp > 0) { sb.append(temp) .append(" ") .append(timesString.get(i)) .append(temp > 1 ? "s" : "") .append(" ago"); break; } } return sb.toString().isEmpty() ? "now" : sb.toString(); } } 

Ecco la mia implementazione Java di questo

  public static String relativeDate(Date date){ Date now=new Date(); if(date.before(now)){ int days_passed=(int) TimeUnit.MILLISECONDS.toDays(now.getTime() - date.getTime()); if(days_passed>1)return days_passed+" days ago"; else{ int hours_passed=(int) TimeUnit.MILLISECONDS.toHours(now.getTime() - date.getTime()); if(hours_passed>1)return days_passed+" hours ago"; else{ int minutes_passed=(int) TimeUnit.MILLISECONDS.toMinutes(now.getTime() - date.getTime()); if(minutes_passed>1)return minutes_passed+" minutes ago"; else{ int seconds_passed=(int) TimeUnit.MILLISECONDS.toSeconds(now.getTime() - date.getTime()); return seconds_passed +" seconds ago"; } } } } else { return new SimpleDateFormat("HH:mm:ss MM/dd/yyyy").format(date).toString(); } } 

per me funziona

 public class TimeDifference { int years; int months; int days; int hours; int minutes; int seconds; String differenceString; public TimeDifference(@NonNull Date curdate, @NonNull Date olddate) { float diff = curdate.getTime() - olddate.getTime(); if (diff >= 0) { int yearDiff = Math.round((diff / (AppConstant.aLong * AppConstant.aFloat)) >= 1 ? (diff / (AppConstant.aLong * AppConstant.aFloat)) : 0); if (yearDiff > 0) { years = yearDiff; setDifferenceString(years + (years == 1 ? " year" : " years") + " ago"); } else { int monthDiff = Math.round((diff / AppConstant.aFloat) >= 1 ? (diff / AppConstant.aFloat) : 0); if (monthDiff > 0) { if (monthDiff > AppConstant.ELEVEN) { monthDiff = AppConstant.ELEVEN; } months = monthDiff; setDifferenceString(months + (months == 1 ? " month" : " months") + " ago"); } else { int dayDiff = Math.round((diff / (AppConstant.bFloat)) >= 1 ? (diff / (AppConstant.bFloat)) : 0); if (dayDiff > 0) { days = dayDiff; if (days == AppConstant.THIRTY) { days = AppConstant.TWENTYNINE; } setDifferenceString(days + (days == 1 ? " day" : " days") + " ago"); } else { int hourDiff = Math.round((diff / (AppConstant.cFloat)) >= 1 ? (diff / (AppConstant.cFloat)) : 0); if (hourDiff > 0) { hours = hourDiff; setDifferenceString(hours + (hours == 1 ? " hour" : " hours") + " ago"); } else { int minuteDiff = Math.round((diff / (AppConstant.dFloat)) >= 1 ? (diff / (AppConstant.dFloat)) : 0); if (minuteDiff > 0) { minutes = minuteDiff; setDifferenceString(minutes + (minutes == 1 ? " minute" : " minutes") + " ago"); } else { int secondDiff = Math.round((diff / (AppConstant.eFloat)) >= 1 ? (diff / (AppConstant.eFloat)) : 0); if (secondDiff > 0) { seconds = secondDiff; } else { seconds = 1; } setDifferenceString(seconds + (seconds == 1 ? " second" : " seconds") + " ago"); } } } } } } else { setDifferenceString("Just now"); } } public String getDifferenceString() { return differenceString; } public void setDifferenceString(String differenceString) { this.differenceString = differenceString; } public int getYears() { return years; } public void setYears(int years) { this.years = years; } public int getMonths() { return months; } public void setMonths(int months) { this.months = months; } public int getDays() { return days; } public void setDays(int days) { this.days = days; } public int getHours() { return hours; } public void setHours(int hours) { this.hours = hours; } public int getMinutes() { return minutes; } public void setMinutes(int minutes) { this.minutes = minutes; } public int getSeconds() { return seconds; } public void setSeconds(int seconds) { this.seconds = seconds; } } 

Questo è lo script di base. è facile da improvvisare.
Risultato: (XXX ore fa) o (XX giorni fa / Ieri / oggi)

  ,or