Comment calculer « le temps il y a » en Java?
https://stackoverflow.com/questions/3859288
-
27-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Dans Ruby on Rails, il y a une fonctionnalité qui vous permet de prendre une date et d'imprimer comment « il y a longtemps » il était.
Par exemple:
8 minutes ago
8 hours ago
8 days ago
8 months ago
8 years ago
Y at-il un moyen facile de le faire en Java?
La solution
Jetez un oeil à la bibliothèque PrettyTime .
Il est très simple à utiliser:
import org.ocpsoft.prettytime.PrettyTime;
PrettyTime p = new PrettyTime();
System.out.println(p.format(new Date()));
// prints "moments ago"
Vous pouvez également passer dans un lieu pour les messages internationalisés:
PrettyTime p = new PrettyTime(new Locale("fr"));
System.out.println(p.format(new Date()));
// prints "à l'instant"
Comme indiqué dans les commentaires, Android a cette fonctionnalité intégrée dans le android.text.format.DateUtils classe.
Autres conseils
Avez-vous envisagé TimeUnit ENUM? Il peut être très utile pour ce genre de chose
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();
}
Je prends RealHowTo et Ben réponses J et faire ma propre version:
public class TimeAgo {
public static final List<Long> 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<String> 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));
}}
qui imprimera les éléments suivants
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
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
* "<w> days, <x> hours, <y> 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
*/
}
}
Format une durée en millisecondes dans un format lisible par l'homme
Ceci est basé sur la réponse de RealHowTo si vous l'aimez, donnez-lui / elle un peu d'amour aussi.
Cette version nettoyée permet de spécifier la plage de temps que vous pourriez être intéressé.
Il gère aussi le « et » partie un peu différemment. Je trouve souvent lors de l'assemblage des chaînes avec un delimiter il est plus facile de sauter ofter la logique compliquée et simplement supprimer le dernier délimiteur lorsque vous avez terminé.
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();
}
}
Petit code pour donner un tourbillon:
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));
}
}
}
qui génèrerait les éléments suivants:
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
Et au cas où quelqu'un a besoin jamais, voici est une classe qui convertit une chaîne comme ci-dessus retour en millisecondes . Il est très utile pour permettre aux gens de préciser les délais d'attente de choses différentes dans le texte lisible.
il y a un moyen simple de faire cela:
Disons que vous voulez le temps il y a 20 minutes:
Long minutesAgo = new Long(20);
Date date = new Date();
Date dateIn_X_MinAgo = new Date (date.getTime() - minutesAgo*60*1000);
c'est tout ..
Si vous cherchez un simple "Aujourd'hui", "Hier" ou "il y a x jours".
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";
}
java.time
Utilisation du java.time cadre intégré Java 8 et versions ultérieures.
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");
A propos de intégré solutions:
Java ne possède pas de support intégré pour le formatage des temps relatifs, pas non plus Java-8 et son nouveau java.time paquet. Si vous avez seulement besoin anglais et rien d'autre alors et seulement alors une solution faite à la main pourrait être acceptable - voir la réponse de @RealHowTo (même si elle a l'inconvénient fort de ne pas prendre en compte le fuseau horaire pour la traduction de deltas instantanées à l'heure locale unités!). Quoi qu'il en soit, si vous voulez éviter des solutions de contournement complexes cultivés à domicile en particulier pour d'autres endroits, vous avez besoin d'une bibliothèque externe.
Dans ce dernier cas, je vous recommande d'utiliser ma bibliothèque Time4J (ou Time4A sur Android). Il offre une plus grande flexibilité et plus i18n puissance . La classe net.time4j.PrettyTime a sept méthodes printRelativeTime...(...) à cet effet. Exemple d'utilisation d'une horloge de test en tant que source de temps:
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 autre exemple utilisant java.time.Instant en entrée:
String relativeTime =
PrettyTime.of(Locale.ENGLISH)
.printRelativeInStdTimezone(Moment.from(Instant.EPOCH));
System.out.println(relativeTime); // 45 years ago
Cette bibliothèque via des supports sa dernière version (v4.17) 80 langues et aussi certains paramètres régionaux spécifiques de pays (en particulier pour l'espagnol, anglais, arabe, français). Les données i18n-sont principalement basées sur la nouvelle version CLDR v29 . D'autres raisons importantes pour lesquelles d'utiliser cette bibliothèque sont bons soutien aux règles plurielles (qui sont souvent différents de l'anglais dans d'autres lieux), le style format abrégé (par exemple: « 1 sec il y a ") et les moyens d'expression pour en tenant compte des fuseaux horaires . Time4J est encore au courant de ces détails exotiques comme secondes bissextiles dans le calcul des temps relatifs (pas vraiment important, mais il forme un message lié à l'horizon de l'attente). compatibilité avec Java-8 existe en raison de méthodes de conversion facilement disponibles pour les types comme java.time.Instant ou java.time.Period.
Y a-t-il des inconvénients? Seulement deux.
- La bibliothèque est pas petit (aussi à cause de son grand dépôt de données i18n-).
- L'API est pas bien connue si les connaissances communautaires et de soutien ne sont pas encore disponible sinon la documentation est assez détaillé et complet.
alternatives (Compact):
Si vous cherchez une solution plus petite et ne nécessitent pas autant de fonctionnalités et sont prêts à tolérer les éventuels problèmes de qualité liés aux données i18n-alors:
-
Je recommande ocpsoft / PrettyTime (soutien aux 32 langues (en fait bientôt 34) adéquat pour les
java.util.Dateseulement - voir la réponse de @ataylor). L'industrie CLDR standard (du consortium Unicode) avec son grand fond communautaire est pas une base unfortunatly des données i18n-donc de nouvelles améliorations ou des améliorations de données peuvent prendre un certain temps ... -
Si vous êtes sur Android alors la classe d'aide android.text.format.DateUtils est un mince intégré alternatif (voir d'autres commentaires et réponses ici, avec l'inconvénient qu'il a pas de soutien pendant des années et des mois. et je suis sûr que très peu de gens comme l'API de style de cette classe d'aide.
-
Si vous êtes fan de Joda-Time vous pouvez regarder sa classe PeriodFormat (prise en charge 14 langues en version v2.9.4, de l'autre côté: Joda- Le temps est sûrement pas compact, aussi, donc je le mentionne ici juste pour être complet). Cette bibliothèque n'est pas une vraie réponse parce que les temps ne sont pas pris en charge par rapport à tous. Vous devrez ajouter le littéral « il y a » au moins (et décapage manuellement toutes les unités inférieures de formats de liste générés - maladroits). Contrairement à Time4J ou Android DateUtILS, il n'a pas de support spécial pour les abréviations ou la commutation automatique de temps relatifs à des représentations de temps absolu. Comme PrettyTime, il est totalement dépendant des contributions non confirmées des membres privés de la Java communauté à son i18n-données.
Je créé simple Port Java timeago du plug-in jquery-timeago qui fait ce que vous demandez.
TimeAgo time = new TimeAgo();
String minutes = time.timeAgo(System.currentTimeMillis() - (15*60*1000)); // returns "15 minutes ago"
Dans le cas où vous développez une application pour Android, il fournit la classe utilitaire DateUtils #getRelativeTimeSpanString () méthode utilitaire.
De la documentation pour
CharSequence getRelativeTimeSpanString (longtemps, longtemps, longtemps minResolution)
Retourne une chaîne décrivant le « temps » comme un temps par rapport à « maintenant ». Temps portées dans le passé sont mis en forme comme « il y a 42 minutes ». Temps portées à l'avenir sont mis en forme comme « dans 42 minutes ».
Vous passerez votre timestamp comme temps et System.currentTimeMillis() comme maintenant . Le minResolution vous permet de spécifier le timespan minimum le rapport.
Par exemple, un temps de 3 secondes dans le passé seront présentés comme « il y a 0 minutes » si cela est réglé sur MINUTE_IN_MILLIS. Passer l'un des 0, MINUTE_IN_MILLIS, HOUR_IN_MILLIS, DAY_IN_MILLIS, WEEK_IN_MILLIS etc.
Le paquet Joda-temps , a la notion de Périodes . Vous pouvez effectuer des opérations arithmétiques avec des périodes et DateTimes.
De la docs :
public boolean isRentalOverdue(DateTime datetimeRented) {
Period rentalPeriod = new Period().withDays(2).withHours(12);
return datetimeRented.plus(rentalPeriod).isBeforeNow();
}
Vous pouvez utiliser cette fonction il y a le temps de calculer
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) Ici TIME_AGO est-en microsecondes
Basé sur un tas de réponses ici, j'ai créé ce qui suit pour mon cas d'utilisation.
Exemple d'utilisation:
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<Long> 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<String> 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();
}
}
Après de longues recherches, je trouve cela.
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;
}
}
Pour Android Exactement comme l'a dit Ravi, mais étant donné que beaucoup de gens veulent il suffit de copier-coller la chose ici est.
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("");
}
Explication pour les personnes qui ont plus de temps
- Vous obtenez les données de quelque part. D'abord, vous devez trouver le format de lui.
Ex. Je reçois les données d'un serveur au format Mer Jan 2016 09:32:35 27 GMT [ce qui est probablement pas votre cas]
est traduit en
SimpleDateFormat formatter = new SimpleDateFormat ( "EEE, dd MMM aaaa hh: mm: ss Z");
comment puis-je le sais? Lisez le ici.
Alors après que je l'analyse syntaxique, je reçois une date. cette date que je mets dans la getRelativeTimeSpanString (sans aucun paramètre supplémentaire est bien pour moi, pour être par défaut en minutes)
Vous obtiendrez une exception si vous ne figure pas le correcte analyse syntaxique chaîne , quelque chose comme: exception au caractère 5 . Regardez le caractère 5 et corriger votre chaîne d'analyse initiale. . Vous pouvez obtenir une autre exception, répétez ces étapes jusqu'à ce que vous avez la bonne formule.
Voici mon implémentation Java de cette
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();
}
}
ça marche pour moi
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;
} }
Ceci est le script très basique. il est facile de improvisée.
Résultat: (Heures XXX Ago), ou (XX jours / Hier / Aujourd'hui)
<span id='hourpost'></span>
,or
<span id='daypost'></span>
<script>
var postTime = new Date('2017/6/9 00:01');
var now = new Date();
var difference = now.getTime() - postTime.getTime();
var minutes = Math.round(difference/60000);
var hours = Math.round(minutes/60);
var days = Math.round(hours/24);
var result;
if (days < 1) {
result = "Today";
} else if (days < 2) {
result = "Yesterday";
} else {
result = days + " Days ago";
}
document.getElementById("hourpost").innerHTML = hours + "Hours Ago" ;
document.getElementById("daypost").innerHTML = result ;
</script>
pour cela que je l'ai Just Now, seconds ago, min ago, hrs ago, days ago, weeks ago, months ago, years ago fait dans cet exemple, vous pouvez analyser comme la date 2018-09-05T06:40:46.183Z ou de tout autre comme ci-dessous
AJOUTZ valeur string.xml
<string name="lbl_justnow">Just Now</string>
<string name="lbl_seconds_ago">seconds ago</string>
<string name="lbl_min_ago">min ago</string>
<string name="lbl_mins_ago">mins ago</string>
<string name="lbl_hr_ago">hr ago</string>
<string name="lbl_hrs_ago">hrs ago</string>
<string name="lbl_day_ago">day ago</string>
<string name="lbl_days_ago">days ago</string>
<string name="lbl_lstweek_ago">last week</string>
<string name="lbl_week_ago">weeks ago</string>
<string name="lbl_onemonth_ago">1 month ago</string>
<string name="lbl_month_ago">months ago</string>
<string name="lbl_oneyear_ago" >last year</string>
<string name="lbl_year_ago" >years ago</string>
code java essayer ci-dessous
public String getFormatDate(String postTime1) {
Calendar cal=Calendar.getInstance();
Date now=cal.getTime();
String disTime="";
try {
Date postTime;
//2018-09-05T06:40:46.183Z
postTime = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").parse(postTime1);
long diff=(now.getTime()-postTime.getTime()+18000)/1000;
//for months
Calendar calObj = Calendar.getInstance();
calObj.setTime(postTime);
int m=calObj.get(Calendar.MONTH);
calObj.setTime(now);
SimpleDateFormat monthFormatter = new SimpleDateFormat("MM"); // output month
int mNow = Integer.parseInt(monthFormatter.format(postTime));
diff = diff-19800;
if(diff<15) { //below 15 sec
disTime = getResources().getString(R.string.lbl_justnow);
} else if(diff<60) {
//below 1 min
disTime= diff+" "+getResources().getString(R.string.lbl_seconds_ago);
} else if(diff<3600) {//below 1 hr
// convert min
long temp=diff/60;
if(temp==1) {
disTime= temp + " " +getResources().getString(R.string.lbl_min_ago);
} else {
disTime = temp + " " +getResources().getString(R.string.lbl_mins_ago);
}
} else if(diff<(24*3600)) {// below 1 day
// convert hr
long temp= diff/3600;
System.out.println("hey temp3:"+temp);
if(temp==1) {
disTime = temp + " " +getResources().getString(R.string.lbl_hr_ago);
} else {
disTime = temp + " " +getResources().getString(R.string.lbl_hrs_ago);
}
} else if(diff<(24*3600*7)) {// below week
// convert days
long temp=diff/(3600*24);
if (temp==1) {
// disTime = "\nyesterday";
disTime = temp + " " +getResources().getString(R.string.lbl_day_ago);
} else {
disTime = temp + " " +getResources().getString(R.string.lbl_days_ago);
}
} else if(diff<((24*3600*28))) {// below month
// convert week
long temp=diff/(3600*24*7);
if (temp <= 4) {
if (temp < 1) {
disTime = getResources().getString(R.string.lbl_lstweek_ago);
}else{
disTime = temp + " " + getResources().getString(R.string.lbl_week_ago);
}
} else {
int diffMonth = mNow - m;
Log.e("count : ", String.valueOf(diffMonth));
disTime = diffMonth + " " + getResources().getString(R.string.lbl_month_ago);
}
}else if(diff<((24*3600*365))) {// below year
// convert month
long temp=diff/(3600*24*30);
System.out.println("hey temp2:"+temp);
if (temp <= 12) {
if (temp == 1) {
disTime = getResources().getString(R.string.lbl_onemonth_ago);
}else{
disTime = temp + " " + getResources().getString(R.string.lbl_month_ago);
}
}
}else if(diff>((24*3600*365))) { // above year
// convert year
long temp=diff/(3600*24*30*12);
System.out.println("hey temp8:"+temp);
if (temp == 1) {
disTime = getResources().getString(R.string.lbl_oneyear_ago);
}else{
disTime = temp + " " + getResources().getString(R.string.lbl_year_ago);
}
}
} catch(Exception e) {
e.printStackTrace();
}
return disTime;
}
Vous pouvez utiliser la bibliothèque Java RelativeDateTimeFormatter , il fait exactement cela :
RelativeDateTimeFormatter fmt = RelativeDateTimeFormatter.getInstance();
fmt.format(1, Direction.NEXT, RelativeUnit.DAYS); // "in 1 day"
fmt.format(3, Direction.NEXT, RelativeUnit.DAYS); // "in 3 days"
fmt.format(3.2, Direction.LAST, RelativeUnit.YEARS); // "3.2 years ago"
fmt.format(Direction.LAST, AbsoluteUnit.SUNDAY); // "last Sunday"
fmt.format(Direction.THIS, AbsoluteUnit.SUNDAY); // "this Sunday"
fmt.format(Direction.NEXT, AbsoluteUnit.SUNDAY); // "next Sunday"
fmt.format(Direction.PLAIN, AbsoluteUnit.SUNDAY); // "Sunday"
fmt.format(Direction.LAST, AbsoluteUnit.DAY); // "yesterday"
fmt.format(Direction.THIS, AbsoluteUnit.DAY); // "today"
fmt.format(Direction.NEXT, AbsoluteUnit.DAY); // "tomorrow"
fmt.format(Direction.PLAIN, AbsoluteUnit.NOW); // "now"
J'utilise Instant, date et DateTimeUtils. Les données (date) qui est stocké dans la base de données type de chaîne, puis convertir pour devenir instantanée.
/*
This method is to display ago.
Example: 3 minutes ago.
I already implement the latest which is including the Instant.
Convert from String to Instant and then parse to Date.
*/
public String convertTimeToAgo(String dataDate) {
//Initialize
String conversionTime = null;
String suffix = "Yang Lalu";
Date pastTime;
//Parse from String (which is stored as Instant.now().toString()
//And then convert to become Date
Instant instant = Instant.parse(dataDate);
pastTime = DateTimeUtils.toDate(instant);
//Today date
Date nowTime = new Date();
long dateDiff = nowTime.getTime() - pastTime.getTime();
long second = TimeUnit.MILLISECONDS.toSeconds(dateDiff);
long minute = TimeUnit.MILLISECONDS.toMinutes(dateDiff);
long hour = TimeUnit.MILLISECONDS.toHours(dateDiff);
long day = TimeUnit.MILLISECONDS.toDays(dateDiff);
if (second < 60) {
conversionTime = second + " Saat " + suffix;
} else if (minute < 60) {
conversionTime = minute + " Minit " + suffix;
} else if (hour < 24) {
conversionTime = hour + " Jam " + suffix;
} else if (day >= 7) {
if (day > 30) {
conversionTime = (day / 30) + " Bulan " + suffix;
} else if (day > 360) {
conversionTime = (day / 360) + " Tahun " + suffix;
} else {
conversionTime = (day / 7) + " Minggu " + suffix;
}
} else if (day < 7) {
conversionTime = day + " Hari " + suffix;
}
return conversionTime;
}
java.time
Le Réponse Habsq a la bonne idée, mais les mauvaises méthodes.
Pour une période de temps-non fixé à la ligne de temps à l'échelle des années mois-jours, l'utilisation Period . Pour les jours qui signifie des morceaux de 24 heures de temps sans rapport au calendrier et heures-minutes-secondes, utilisez Duration . Le mélange des deux échelles fait rarement de sens.
Duration
Commencez par aller chercher le moment actuel comme on le voit dans UTC , en utilisant le Instant classe.
Instant now = Instant.now(); // Capture the current moment as seen in UTC.
Instant then = now.minus( 8L , ChronoUnit.HOURS ).minus( 8L , ChronoUnit.MINUTES ).minus( 8L , ChronoUnit.SECONDS );
Duration d = Duration.between( then , now );
Générer du texte pendant des heures, minutes et secondes.
// Generate text by calling `to…Part` methods.
String output = d.toHoursPart() + " hours ago\n" + d.toMinutesPart() + " minutes ago\n" + d.toSecondsPart() + " seconds ago";
Dump à la console.
System.out.println( "From: " + then + " to: " + now );
System.out.println( output );
De: 2019-06-04T11: 53: 55.714965Z à: 2019-06-04T20: 02: 03.714965Z
il y a 8 heures
il y a 8 minutes
il y a 8 secondes
Period
Commencez par obtenir la date actuelle.
Un fuseau horaire est cruciale pour déterminer une date. Pour un moment donné, la date varie dans le monde entier par zone. Par exemple, quelques minutes après minuit dans Paris France est un nouveau jour tout en « hier » Montréal Québec .
Si aucun fuseau horaire est spécifié, la machine virtuelle Java applique implicitement sa zone actuelle de temps par défaut. Ce défaut peut modifier à tout moment lors de l'exécution (!), vos résultats peuvent varier. Mieux vaut indiquer votre zone désirée / heure prévue explicitement comme argument. Si critique, vérifiez la zone avec votre utilisateur.
Indiquez un nom de fuseau horaire approprié dans le format de Continent/Region, tels que America/Montreal, Africa/Casablanca ou Pacific/Auckland. Ne jamais utiliser l'abréviation 2-4 lettres telles que EST ou IST comme ils sont pas fuseaux horaires, véritables non standardisés, et même pas uniques (!).
ZoneId z = ZoneId.of( "America/Montreal" ) ;
LocalDate today = LocalDate.now( z ) ;
Recréer une date il y a huit jours, des mois et des années.
LocalDate then = today.minusYears( 8 ).minusMonths( 8 ).minusDays( 7 ); // Notice the 7 days, not 8, because of granularity of months.
Calculer le temps écoulé.
Period p = Period.between( then , today );
Créer la chaîne de "temps il y a" des pièces.
String output = p.getDays() + " days ago\n" + p.getMonths() + " months ago\n" + p.getYears() + " years ago";
Dump à la console.
System.out.println( "From: " + then + " to: " + today );
System.out.println( output );
De: 2010-09-27 à: 04/06/2019
il y a 8 jours
il y a 8 mois
il y a 8 ans
A propos de java.time
Le java.time cadre est construit en Java 8 et versions ultérieures. Ces classes supplantent la problématique vieux classes date de temps de hérités tels que java.util.Date , Calendar , et SimpleDateFormat .
Pour en savoir plus, Consultez le Oracle Tutoriel . Et la recherche Stack Overflow pour de nombreux exemples et explications. Spécification est JSR 310 .
Le projet Joda-Time , maintenant < a href = "https://en.wikipedia.org/wiki/Maintenance_mode" rel = "nofollow noreferrer"> mode maintenance , conseille la migration vers la page java.time classes.
Vous pouvez échanger des java.time objets directement avec votre base de données. Utilisez un pilote JDBC conforme JDBC 4.2 ou version ultérieure. Pas besoin de chaînes, pas besoin de classes java.sql.*.
Où obtenir les classes java.time?
- Java SE 8 , Java SE 9 , Java SE 10 , Java SE 11 , et plus tard - une partie de l'API Java standard avec une implémentation groupée.
- Java 9 ajoute quelques fonctionnalités mineures et corrections.
- Java SE 6 et Java SE 7
- La plupart des java.time fonctionnalité est de retour à Java 6 Ported & 7 Android
- Les versions ultérieures de bundle implémentations Android du java.time classes.
- Pour plus tôt Android (<26), ThreeTenABP projet ThreeTen-Backport (mentionné ci-dessus). Voir Comment utiliser ThreeTenABP ... .
Le projet ThreeTen-Extra étend java.time avec des classes supplémentaires. Ce projet est un terrain d'essai pour des ajouts futurs possibles à java.time. Vous trouverez peut-être des classes utiles ici, comme
Interval,YearWeek,YearQuarteret plus . - La plupart des java.time fonctionnalité est de retour à Java 6 Ported & 7 Android
Cette fonction calcule en Java pur, cependant, cette fonction ne montre pas comme "1 hour, 3 minutes" partials, il utilisera la plus grande valeur de conteneur (heures, jours, mois, etc.), il peut, et autour de la valeur la plus proche .
private String agoFromTime(long seconds) {
long minutes = seconds / 60;
long hours = seconds / 3600;
long days = seconds / 86400;
long years = seconds / (86400 * 365);
String postfix;
long result;
if(years > 0) result = Math.round(seconds / (86400.0 * 365.0));
else if(days > 0) result = Math.round(seconds / 86400.0);
else if(hours > 0) result = Math.round(seconds / 3600.0);
else if(minutes > 0) result = Math.round(seconds / 60.0);
else result = seconds;
if(years > 0) postfix = " year";
else if(days > 0) postfix = " day";
else if(hours > 0) postfix = " hour";
else if(minutes > 0) postfix = " minute";
else postfix = " second";
return result + postfix + ((result != 1) ? "s" : "");
}
}
