Как рассчитать "время назад" в Java?
В Ruby on Rails есть функция, которая позволяет вам взять любую дату и распечатать, как давно она была.
Например:
8 minutes ago
8 hours ago
8 days ago
8 months ago
8 years ago
Есть ли простой способ сделать это на Java?
33 ответа
Взгляните на библиотеку PrettyTime.
Это довольно просто использовать:
import org.ocpsoft.prettytime.PrettyTime;
PrettyTime p = new PrettyTime();
System.out.println(p.format(new Date()));
// prints "moments ago"
Вы также можете передать локаль для интернационализированных сообщений:
PrettyTime p = new PrettyTime(new Locale("fr"));
System.out.println(p.format(new Date()));
// prints "à l'instant"
Как отмечено в комментариях, Android имеет эту функцию, встроенную в android.text.format.DateUtils учебный класс.
Рассматривали ли вы перечисление TimeUnit? Это может быть очень полезно для такого рода вещей
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();
}
Я беру ответы RealHowTo и Ben J и делаю свою собственную версию:
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));
}}
который напечатает следующее
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
*/
}
}
more @ Форматировать длительность в миллисекундах в удобочитаемом формате
Это основано на ответе RealHowTo, так что, если вам это нравится, дайте ему / ей тоже немного любви.
Эта очищенная версия позволяет вам указать диапазон времени, который вас может заинтересовать.
Он также обрабатывает части "и" немного по-другому. Я часто нахожу, что при соединении строк с разделителем проще пропустить сложную логику и просто удалить последний разделитель, когда вы закончите.
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();
}
}
Небольшой код, чтобы привести его в движение:
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));
}
}
}
Который выведет следующее:
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
И в случае, если кому-то это понадобится, вот класс, который преобразует любую строку, подобную приведенной выше, в миллисекунды. Это довольно полезно для того, чтобы люди могли указывать тайм-ауты различных вещей в читаемом тексте.
Есть простой способ сделать это:
скажем, вы хотите время 20 минут назад:
Long minutesAgo = new Long(20);
Date date = new Date();
Date dateIn_X_MinAgo = new Date (date.getTime() - minutesAgo*60*1000);
вот и все..
О встроенных решениях:
Java не имеет встроенной поддержки форматирования относительного времени, также как и Java-8 и его новый пакет. java.time, Если вам нужен только английский язык и ничего больше, то и только тогда может быть приемлемым решение, созданное вручную - см. Ответ @RealHowTo (хотя он имеет серьезный недостаток - не учитывать часовой пояс для перевода мгновенных дельт в местное время). единицы!). В любом случае, если вы хотите избежать домашних сложных обходных путей, особенно для других языков, вам нужна внешняя библиотека.
В последнем случае я рекомендую использовать мою библиотеку Time4J (или Time4A на Android). Он предлагает большую гибкость и большую мощность i18n. Класс net.time4j.PrettyTime имеет семь методов printRelativeTime...(...) для этого. Пример использования тестовых часов в качестве источника времени:
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)
Еще один пример использования java.time.Instant как вход:
String relativeTime =
PrettyTime.of(Locale.ENGLISH)
.printRelativeInStdTimezone(Moment.from(Instant.EPOCH));
System.out.println(relativeTime); // 45 years ago
Эта библиотека поддерживает через свою последнюю версию (v4.17) 80 языков, а также некоторые локали, специфичные для конкретной страны (особенно для испанского, английского, арабского, французского). Данные i18n в основном основаны на новейшей CLDR-версии v29. Другими важными причинами использования этой библиотеки являются хорошая поддержка множественных правил (которые часто отличаются от английского в других локалях), сокращенный стиль формата (например, "1 секунда назад") и выразительные способы учета часовых поясов. Time4J даже знает о таких экзотических деталях, как високосные секунды в вычислениях относительного времени (не очень важно, но он формирует сообщение, связанное с горизонтом ожидания). Совместимость с Java-8 существует благодаря легко доступным методам преобразования для таких типов, как java.time.Instant или же java.time.Period,
Есть ли недостатки? Только два.
- Библиотека не маленькая (также из-за большого хранилища i18n-data).
- API не очень хорошо известен, поэтому знания и поддержка сообщества пока недоступны, в противном случае прилагаемая документация является довольно подробной и полной.
(Компактные) альтернативы:
Если вы ищете решение меньшего размера и не нуждаетесь в таком количестве функций и готовы терпеть возможные проблемы с качеством, связанные с i18n-data, то:
Я бы порекомендовал ocpsoft / PrettyTime (поддержка фактически 32 языков (скоро 34?), Подходящих для работы с
java.util.Dateтолько - см. ответ @ataylor). К сожалению, промышленный стандарт CLDR (от консорциума Unicode) с большим опытом работы в сообществе не является базой данных i18n, поэтому дальнейшее усовершенствование или улучшение данных может занять некоторое время...Если вы работаете на Android, то вспомогательный класс android.text.format.DateUtils является тонкой встроенной альтернативой (см. Другие комментарии и ответы здесь, с тем недостатком, что он не поддерживает годами и месяцами. И я уверен, что только очень немногим нравится стиль API этого вспомогательного класса.
Если вы являетесь поклонником Joda-Time, то вы можете взглянуть на его класс PeriodFormat (поддержка 14 языков в выпуске v2.9.4, с другой стороны: Joda-Time, конечно, тоже не компактен, поэтому я упомяну это здесь только для полнота). Эта библиотека не является реальным ответом, потому что относительное время вообще не поддерживается. Вам нужно будет как минимум добавить литерал "назад" (и вручную убирать все нижние единицы из сгенерированных форматов списка - неудобно). В отличие от Time4J или Android-DateUtils, он не имеет специальной поддержки сокращений или автоматического переключения с относительного времени на представление абсолютного времени. Как и PrettyTime, он полностью зависит от неподтвержденных вкладов частных членов Java-сообщества в его i18n-данные.
java.time
Ответ от Habsq имеет правильную идею, но неправильные методы.
Для промежутка времени, не привязанного к временной шкале в шкале лет-месяцев-дней, используйте Period, Для дней, обозначающих 24-часовой промежуток времени, не связанный с календарем и часами, минутами и секундами, используйте Duration, Смешивание двух шкал редко имеет какой-либо смысл.
Duration
Начните с выборки текущего момента, как показано в UTC, используя Instant класс.
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 );
Генерация текста для часов, минут и секунд.
// Generate text by calling `to…Part` methods.
String output = d.toHoursPart() + " hours ago\n" + d.toMinutesPart() + " minutes ago\n" + d.toSecondsPart() + " seconds ago";
Дамп на консоль.
System.out.println( "From: " + then + " to: " + now );
System.out.println( output );
С: 2019-06-04T11:53:55.714965Z до: 2019-06-04T20: 02: 03.714965Z
8 часов назад
8 минут назад
8 секунд назад
Period
Начните с получения текущей даты.
Часовой пояс имеет решающее значение при определении даты. В любой момент времени дата меняется по всему земному шару в зависимости от зоны. Например, через несколько минут после полуночи в Париже Франция - новый день, а в Монреале-Квебеке все еще "вчера".
Если часовой пояс не указан, JVM неявно применяет свой текущий часовой пояс по умолчанию. Это значение по умолчанию может измениться в любой момент во время выполнения (!), Поэтому ваши результаты могут отличаться. Лучше явно указать желаемый / ожидаемый часовой пояс в качестве аргумента. Если критично, подтвердите зону с вашим пользователем.
Укажите правильное название часового пояса в формате Continent/Region, такие как America/Montreal, Africa/Casablanca, или же Pacific/Auckland, Никогда не используйте 2-4 буквенное сокращение, такое как EST или же IST поскольку они не являются истинными часовыми поясами, не стандартизированы и даже не уникальны (!).
ZoneId z = ZoneId.of( "America/Montreal" ) ;
LocalDate today = LocalDate.now( z ) ;
Воссоздайте дату восемь дней, месяцев и лет назад.
LocalDate then = today.minusYears( 8 ).minusMonths( 8 ).minusDays( 7 ); // Notice the 7 days, not 8, because of granularity of months.
Рассчитать прошедшее время.
Period p = Period.between( then , today );
Построить строку из кусочков "времени назад".
String output = p.getDays() + " days ago\n" + p.getMonths() + " months ago\n" + p.getYears() + " years ago";
Дамп на консоль.
System.out.println( "From: " + then + " to: " + today );
System.out.println( output );
С: 2010-09-27 по: 2019-06-04
8 дней назад
8 месяцев назад
8 лет назад
О java.time
Инфраструктура java.time встроена в Java 8 и более поздние версии. Эти классы вытесняют проблемные старые классы даты и времени, такие как java.util.Date, Calendar & SimpleDateFormat,
Чтобы узнать больше, смотрите Oracle Tutorial. И поиск переполнения стека для многих примеров и объяснений. Спецификация JSR 310.
Проект Joda-Time, находящийся сейчас в режиме обслуживания, рекомендует перейти на классы java.time.
Вы можете обмениваться объектами java.time напрямую с вашей базой данных. Используйте драйвер JDBC, соответствующий JDBC 4.2 или более поздней версии. Нет необходимости в строках, нет необходимости в java.sql.* классы.
Где взять классы java.time?
- Java SE 8, Java SE 9, Java SE 10, Java SE 11 и более поздние версии - часть стандартного API Java со встроенной реализацией.
- Java 9 добавляет некоторые незначительные функции и исправления.
- Java SE 6 и Java SE 7
- Большая часть функциональности java.time перенесена на Java 6 и 7 в ThreeTen-Backport.
- Android
- Более поздние версии Android связывают реализации классов java.time.
- Для более ранних версий Android (<26) проект ThreeTenABP адаптирует ThreeTen-Backport (упомянутый выше). Смотрите Как использовать ThreeTenABP….
Проект ThreeTen-Extra расширяет java.time дополнительными классами. Этот проект является полигоном для возможных будущих дополнений к java.time. Вы можете найти некоторые полезные классы здесь, такие как Interval, YearWeek, YearQuarter и многое другое.
java.time
Использование фреймворка java.time, встроенного в Java 8 и новее.
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");
Основываясь на множестве ответов здесь, я создал следующее для моего варианта использования.
Пример использования:
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();
}
}
Если вы ищете простой "Сегодня", "Вчера" или "х дней назад".
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";
}
(Из комментария)
Если вам это нужно для Android, просто используйте это:
public static String getTimeAgoFormat(long timestamp) {
return android.text.format.DateUtils.getRelativeTimeSpanString(timestamp).toString();
}
Если вы разрабатываете приложение для Android, оно предоставляет утилиту класса DateUtils для всех таких требований. Взгляните на служебный метод DateUtils#getRelativeTimeSpanString().
Из документов для
CharSequence getRelativeTimeSpanString (долгое время, длинное сейчас, долгое minResolution)
Возвращает строку, описывающую "время" как время относительно "сейчас". Промежуток времени в прошлом форматируется как "42 минуты назад". Промежуток времени в будущем отформатирован как "Через 42 минуты".
Вы будете передавать свои timestamp как раз и System.currentTimeMillis() как сейчас. minResolution позволяет указать минимальное время для отчета.
Например, время в 3 секунды в прошлом будет сообщаться как "0 минут назад", если для этого параметра установлено значение MINUTE_IN_MILLIS. Передайте один из 0, MINUTE_IN_MILLIS, HOUR_IN_MILLIS, DAY_IN_MILLIS, WEEK_IN_MILLIS и т. Д.
Я создал простой порт Java timeago из плагина jquery-timeago, который делает то, что вы просите.
TimeAgo time = new TimeAgo();
String minutes = time.timeAgo(System.currentTimeMillis() - (15*60*1000)); // returns "15 minutes ago"
Вы можете использовать эту функцию для расчета времени назад
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) Здесь time_ago в микросекундах
private const val SECOND_MILLIS = 1
private const val MINUTE_MILLIS = 60 * SECOND_MILLIS
private const val HOUR_MILLIS = 60 * MINUTE_MILLIS
private const val DAY_MILLIS = 24 * HOUR_MILLIS
object TimeAgo {
fun timeAgo(time: Int): String {
val now = TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis())
if (time > now || time <= 0) {
return "in the future"
}
val diff = now - time
return when {
diff < MINUTE_MILLIS -> "Just now"
diff < 2 * MINUTE_MILLIS -> "a minute ago"
diff < 60 * MINUTE_MILLIS -> "${diff / MINUTE_MILLIS} minutes ago"
diff < 2 * HOUR_MILLIS -> "an hour ago"
diff < 24 * HOUR_MILLIS -> "${diff / HOUR_MILLIS} hours ago"
diff < 48 * HOUR_MILLIS -> "yesterday"
else -> "${diff / DAY_MILLIS} days ago"
}
}
}
Вызов
val String = timeAgo(unixTimeStamp)
чтобы узнать время назад в Котлине
Joda-Time Package, имеет понятие периодов. Вы можете сделать арифметику с Periods и DateTimes.
Из документов:
public boolean isRentalOverdue(DateTime datetimeRented) {
Period rentalPeriod = new Period().withDays(2).withHours(12);
return datetimeRented.plus(rentalPeriod).isBeforeNow();
}
Это не красиво... но самое близкое, что я могу придумать, это использование Joda-Time (как описано в этом посте: Как рассчитать прошедшее время с помощью Joda Time?
java.time
Ты можешь использовать <tcode id="66211"></tcode> и <tcode id="66212"></tcode>которые основаны на стандартах ISO-8601 и были введены в Java-8 как часть реализации JSR-310 . В Java-9 были введены еще несколько удобных методов.
- Использовать
Durationдля расчета количества или количества времени на основе времени. Доступ к нему можно получить, используя единицы измерения продолжительности, такие как наносекунды, секунды, минуты и часы. Кроме того, можно использовать единицу ДНЕЙ, которая считается равной 24 часам, таким образом игнорируя эффекты перехода на летнее время. - Используется для расчета количества времени на основе даты. Доступ к нему можно получить, используя единицы измерения на основе периода, такие как дни, месяцы и годы.
Демо:
import java.time.Duration;
import java.time.LocalDateTime;
import java.time.Month;
public class Main {
public static void main(String[] args) {
// An arbitrary local date and time
LocalDateTime startDateTime = LocalDateTime.of(2020, Month.DECEMBER, 10, 15, 20, 25);
// Current local date and time
LocalDateTime endDateTime = LocalDateTime.now();
Duration duration = Duration.between(startDateTime, endDateTime);
// Default format
System.out.println(duration);
// Custom format
// ####################################Java-8####################################
String formattedElapsedTime = String.format("%d days, %d hours, %d minutes, %d seconds, %d nanoseconds ago",
duration.toDays(), duration.toHours() % 24, duration.toMinutes() % 60, duration.toSeconds() % 60,
duration.toNanos() % 1000000000);
System.out.println(formattedElapsedTime);
// ##############################################################################
// ####################################Java-9####################################
formattedElapsedTime = String.format("%d days, %d hours, %d minutes, %d seconds, %d nanoseconds ago",
duration.toDaysPart(), duration.toHoursPart(), duration.toMinutesPart(), duration.toSecondsPart(),
duration.toNanosPart());
System.out.println(formattedElapsedTime);
// ##############################################################################
}
}
Вывод:
PT1395H35M7.355288S
58 days, 3 hours, 35 minutes, 7 seconds, 355288000 nanoseconds ago
58 days, 3 hours, 35 minutes, 7 seconds, 355288000 nanoseconds ago
Если у вас есть два момента в
UTC, ты можешь использовать
Instant вместо того
LocalDateTime например
import java.time.Duration;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
public class Main {
public static void main(String[] args) {
// Current moment at UTC
Instant now = Instant.now();
// An instant in the past
Instant startDateTime = now.minus(58, ChronoUnit.DAYS)
.minus(2, ChronoUnit.HOURS)
.minus(54, ChronoUnit.MINUTES)
.minus(24, ChronoUnit.SECONDS)
.minus(808624000, ChronoUnit.NANOS);
Duration duration = Duration.between(startDateTime, now);
// Default format
System.out.println(duration);
// Custom format
// ####################################Java-8####################################
String formattedElapsedTime = String.format("%d days, %d hours, %d minutes, %d seconds, %d nanoseconds ago",
duration.toDays(), duration.toHours() % 24, duration.toMinutes() % 60, duration.toSeconds() % 60,
duration.toNanos() % 1000000000);
System.out.println(formattedElapsedTime);
// ##############################################################################
// ####################################Java-9####################################
formattedElapsedTime = String.format("%d days, %d hours, %d minutes, %d seconds, %d nanoseconds ago",
duration.toDaysPart(), duration.toHoursPart(), duration.toMinutesPart(), duration.toSecondsPart(),
duration.toNanosPart());
System.out.println(formattedElapsedTime);
// ##############################################################################
}
}
Вывод:
PT1394H54M24.808624S
58 days, 2 hours, 54 minutes, 24 seconds, 808624000 nanoseconds ago
58 days, 2 hours, 54 minutes, 24 seconds, 808624000 nanoseconds ago
Демо на
Period:
import java.time.LocalDate;
import java.time.Period;
import java.time.ZoneId;
public class Main {
public static void main(String[] args) {
// Replace ZoneId.systemDefault() with the applicable timezone ID e.g.
// ZoneId.of("Europe/London"). For LocalDate in the JVM's timezone, simply use
// LocalDate.now()
LocalDate endDate = LocalDate.now(ZoneId.systemDefault());
// Let's assume the start date is 1 year, 2 months, and 3 days ago
LocalDate startDate = endDate.minusYears(1).minusMonths(2).minusDays(3);
Period period = Period.between(startDate, endDate);
// Default format
System.out.println(period);
// Custom format
String formattedElapsedPeriod = String.format("%d years, %d months, %d days ago", period.getYears(),
period.getMonths(), period.getDays());
System.out.println(formattedElapsedPeriod);
}
}
Вывод:
P1Y2M3D
1 years, 2 months, 3 days ago
Узнайте о современном API даты и времени из Trail: Date Time .
- По любой причине, если вам нужно придерживаться Java 6 или Java 7, вы можете использовать <em><strong>ThreeTen-Backport,</strong></em> который поддерживает большую часть функциональности java.time для Java 6 и 7.
- Если вы работаете над проектом Android, и ваш уровень API Android по-прежнему не соответствует Java-8, проверьте API-интерфейсы Java 8+, доступные через десугаринг, а также Как использовать ThreeTenABP в Android Project .
Это лучший код, если мы учитываем производительность. Это уменьшает количество вычислений. Минутыпричины рассчитываются только в том случае, если количество секунд превышает 60, а часы рассчитываются только в том случае, если количество минут превышает 60 и т. Д.
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";
}
}
}
}
}
}
}
}
}
После долгих исследований я нашел это.
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;
}
}
Вы можете использовать библиотеку Java RelativeDateTimeFormatter, она делает именно это:
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"
Отметка времени SQL для текущего времени. Установите свой часовой пояс.
ПРИМЕЧАНИЕ 1: Это будет обрабатывать единственное / множественное число.
ПРИМЕЧАНИЕ 2: используется время Джода.
String getElapsedTime(String strMysqlTimestamp) {
DateTimeFormatter formatter = DateTimeFormat.forPattern("YYYY-MM-dd HH:mm:ss.S");
DateTime mysqlDate = formatter.parseDateTime(strMysqlTimestamp).
withZone(DateTimeZone.forID("Asia/Kuala_Lumpur"));
DateTime now = new DateTime();
Period period = new Period(mysqlDate, now);
int seconds = period.getSeconds();
int minutes = period.getMinutes();
int hours = period.getHours();
int days = period.getDays();
int weeks = period.getWeeks();
int months = period.getMonths();
int years = period.getYears();
String elapsedTime = "";
if (years != 0)
if (years == 1)
elapsedTime = years + " year ago";
else
elapsedTime = years + " years ago";
else if (months != 0)
if (months == 1)
elapsedTime = months + " month ago";
else
elapsedTime = months + " months ago";
else if (weeks != 0)
if (weeks == 1)
elapsedTime = weeks + " week ago";
else
elapsedTime = weeks + " weeks ago";
else if (days != 0)
if (days == 1)
elapsedTime = days + " day ago";
else
elapsedTime = days + " days ago";
else if (hours != 0)
if (hours == 1)
elapsedTime = hours + " hour ago";
else
elapsedTime = hours + " hours ago";
else if (minutes != 0)
if (minutes == 1)
elapsedTime = minutes + " minute ago";
else
elapsedTime = minutes + " minutes ago";
else if (seconds != 0)
if (seconds == 1)
elapsedTime = seconds + " second ago";
else
elapsedTime = seconds + " seconds ago";
return elapsedTime;
}
Для Android Точно так же, как сказал Рави, но так как многие люди хотят просто скопировать и вставить, вот и все.
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("");
}
Объяснение для людей, у которых больше времени
- Вы получаете данные откуда-то. Сначала вы должны выяснить его формат.
Ex. Я получаю данные с сервера в формате Ср, 27 января 2016 09:32:35 GMT [это, вероятно, НЕ ваш случай]
это переводится на
SimpleDateFormat formatter = new SimpleDateFormat("EEE, дд МММ гггг ЧЧ: мм: сс Z");
откуда я это знаю? Прочитайте документацию здесь.
Затем, после того, как я проанализировал это, я получил дату. эту дату я добавляю в getRelativeTimeSpanString (без каких-либо дополнительных параметров, это нормально для меня, по умолчанию минуты)
Вы получите исключение, если не выяснили правильную строку синтаксического анализа, что-то вроде: исключение в символе 5. Посмотрите на символ 5 и исправьте исходную строку анализа., Вы можете получить другое исключение, повторяйте эти шаги, пока не получите правильную формулу.
Из-за отсутствия простоты и обновленного ответа следует за более поздней версией Java 8 и выше.
import java.time.*;
import java.time.temporal.*;
public class Time {
public static void main(String[] args) {
System.out.println(LocalTime.now().minus(8, ChronoUnit.MINUTES));
System.out.println(LocalTime.now().minus(8, ChronoUnit.HOURS));
System.out.println(LocalDateTime.now().minus(8, ChronoUnit.DAYS));
System.out.println(LocalDateTime.now().minus(8, ChronoUnit.MONTHS));
}
}
Это версия, которая использует Java Time API, который пытается решить проблемы прошлого для работы с датой и временем.
Javadoc
версия 8https://docs.oracle.com/javase/8/docs/api/index.html?java/time/package-summary.html
версия 11https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/package-summary.html
Руководство W3Schools - https://www.w3schools.com/java/java_date.asp
Статья DZone - https://dzone.com/articles/java-8-date-and-time
Вот моя реализация Java этого
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();
}
}
Я использую Instant, Date и DateTimeUtils. Данные (дата) хранятся в базе данных в виде типа String, а затем преобразуются в Instant.
/*
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;
}
Это очень простой сценарий. его легко импровизировать.
Результат: (XXX часов назад) или (XX дней назад / вчера / сегодня)
<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>
Меня устраивает
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;
} }
Функция getrelativeDateTime предоставит вам дату и время, как вы видите в уведомлении WhatsApp.
Чтобы получить будущую относительную дату и время, добавьте для нее условия. Это создано специально для получения даты и времени, например уведомления WhatsApp.
private static String getRelativeDateTime(long date) {
SimpleDateFormat DateFormat = new SimpleDateFormat("MMM dd, yyyy", Locale.getDefault());
SimpleDateFormat TimeFormat = new SimpleDateFormat(" hh:mm a", Locale.getDefault());
long now = Calendar.getInstance().getTimeInMillis();
long startOfDay = StartOfDay(Calendar.getInstance().getTime());
String Day = "";
String Time = "";
long millSecInADay = 86400000;
long oneHour = millSecInADay / 24;
long differenceFromNow = now - date;
if (date > startOfDay) {
if (differenceFromNow < (oneHour)) {
int minute = (int) (differenceFromNow / (60000));
if (minute == 0) {
int sec = (int) differenceFromNow / 1000;
if (sec == 0) {
Time = "Just Now";
} else if (sec == 1) {
Time = sec + " second ago";
} else {
Time = sec + " seconds ago";
}
} else if (minute == 1) {
Time = minute + " minute ago";
} else if (minute < 60) {
Time = minute + " minutes ago";
}
} else {
Day = "Today, ";
}
} else if (date > (startOfDay - millSecInADay)) {
Day = "Yesterday, ";
} else if (date > (startOfDay - millSecInADay * 7)) {
int days = (int) (differenceFromNow / millSecInADay);
Day = days + " Days ago, ";
} else {
Day = DateFormat.format(date);
}
if (Time.isEmpty()) {
Time = TimeFormat.format(date);
}
return Day + Time;
}
public static long StartOfDay(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
return calendar.getTimeInMillis();
}