كيف تحسب "وقت" في جافا؟
https://stackoverflow.com/questions/3859288
-
27-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russianسؤال
في Ruby on Rails ، هناك ميزة تسمح لك بأخذ أي تاريخ وطباعة كيف كانت "منذ فترة طويلة".
فمثلا:
8 minutes ago
8 hours ago
8 days ago
8 months ago
8 years ago
هل هناك طريقة سهلة للقيام بذلك في جافا؟
المحلول
ألق نظرة على جميل مكتبة.
من السهل الاستخدام:
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 صف دراسي.
نصائح أخرى
هل فكرت في الوقت التعداد؟ يمكن أن يكون مفيدًا جدًا لهذا النوع من الأشياء
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
*/
}
}
أكثر @تنسيق مدة في ميلي ثانية إلى تنسيق قابل للقراءة الإنسان
يعتمد هذا على إجابة 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);
هذا هو..
إذا كنت تبحث عن "اليوم" أو "أمس" أو "X Days".
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
باستخدام 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");
حول مدمج حلول:
لا تملك Java أي دعم مدمج لتنسيق الأوقات النسبية ، وليس أيضًا Java-8 وحزمةها الجديدة java.time. إذا كنت بحاجة إلى اللغة الإنجليزية فقط ولا شيء آخر بعد ذلك ، فقد يكون الحل المصنوع يدويًا مقبولًا - راجع إجابة @RealHowto (على الرغم من أن لديه عيبًا قويًا لعدم مراعاة المنطقة الزمنية لترجمة الدلتا الفورية إلى التوقيت المحلي الوحدات!). على أي حال ، إذا كنت ترغب في تجنب الحلول المعقدة المزروعة بالمنزل وخاصة بالنسبة للمواطين الأخرى ، فأنت بحاجة إلى مكتبة خارجية.
في الحالة الأخيرة ، أوصي باستخدام مكتبتي Time4J (أو Time4a على Android). فإنه يوفر أعظم مرونة ومعظم i18n-power. الفصل 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-data بشكل أساسي على أحدث CLDR-Version V29. الأسباب المهمة الأخرى التي تجعل استخدام هذه المكتبة جيدة دعم قواعد الجمع (التي تختلف غالبًا عن اللغة الإنجليزية في أماكن أخرى) ، نمط التنسيق المختصر (على سبيل المثال: "1 ثانية") وطرق معبرة مع الأخذ في الاعتبار المناطق الزمنية. Time4J حتى على دراية بمثل هذه التفاصيل الغريبة مثل قفزة ثواني في حسابات الأوقات النسبية (ليست مهمة حقًا ولكنها تشكل رسالة تتعلق بأفق التوقع). ال التوافق مع Java-8 موجود بسبب طرق التحويل المتاحة بسهولة لأنواع مثل java.time.Instant أو java.time.Period.
هل هناك أي عيوب؟ اثنين فقط.
- المكتبة ليست صغيرة (أيضًا بسبب مستودعها الكبير I18N-Data).
- واجهة برمجة التطبيقات ليست معروفة جيدًا ، لذا فإن المعرفة المجتمعية والدعم غير متاحين ، وإلا فإن الوثائق المقدمة مفصلة وشاملة.
(مضغوط) البدائل:
إذا كنت تبحث عن حل أصغر ولم تكن بحاجة إلى العديد من الميزات وكنت على استعداد للتسامح مع مشكلات الجودة المحتملة المتعلقة بـ i18n-data ثم:
أوصي OCPSOFT/Prettytime (دعم 32 لغة فعليًا (قريبًا 34؟) مناسبة للعمل مع
java.util.Dateفقط - انظر إجابة Ataylor). إن CLDR المعيار في الصناعة (من اتحاد Unicode) مع خلفيته المجتمعية الكبيرة ليس للأسف قاعدة لـ i18n-data ، لذا فإن المزيد من التحسينات أو تحسينات البيانات قد تستغرق بعض الوقت ...إذا كنت في Android ثم فئة المساعد Android.text.format.dateutils هو بديل ضئيل مدمج (انظر التعليقات والأجوبة الأخرى هنا ، مع العيب الذي لا يوجد دعم له لسنوات وشهور. وأنا متأكد من أن قلة قليلة من الأشخاص مثل طراز API من فئة المساعدة هذه.
إذا كنت من محبي وقت جودا ثم يمكنك إلقاء نظرة على فصلها فترة (دعم 14 لغة في الإصدار v2.9.4 ، على الجانب الآخر: من المؤكد أن وقت Joda ليس مضغوطًا أيضًا ، لذلك أذكرها هنا فقط من أجل الاكتمال). هذه المكتبة ليست إجابة حقيقية لأن الأوقات النسبية غير مدعومة على الإطلاق. ستحتاج إلى إلحاق الحرفي "منذ" على الأقل (وتجريد جميع الوحدات السفلية يدويًا من تنسيقات القائمة التي تم إنشاؤها - محرجًا). على عكس Time4J أو Android-DateUtils ، ليس له دعم خاص للاختصارات أو التبديل التلقائي من الأوقات النسبية إلى تمثيلات الوقت المطلق. مثل Pretty Time ، فهي تعتمد تمامًا على المساهمات غير المؤكدة للأعضاء الخاصين في Java-Community لـ I18N-Data.
لقد خلقت بسيطة جافا تيماغو ميناء jquery-timeago المكون الإضافي الذي يفعل ما تطلبه.
TimeAgo time = new TimeAgo();
String minutes = time.timeAgo(System.currentTimeMillis() - (15*60*1000)); // returns "15 minutes ago"
في حال كنت تقوم بتطوير تطبيق لنظام Android ، فإنه يوفر فئة الأداة المساعدة DateUtils لجميع هذه المتطلبات. ألق نظرة على DateUtils#getRelativetimesPanstring () طريقة المنفعة.
من المستندات
getRelativetimespanstring (وقت طويل ، طويل الآن ، Long 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 إلخ.
يمكنك استخدام هذه الوظيفة لحساب الوقت منذ ذلك الوقت
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 في microsecond
بناءً على مجموعة من الإجابات هنا ، قمت بإنشاء ما يلي لحالة الاستخدام الخاصة بي.
مثال الاستخدام:
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();
}
}
إنها ليست جميلة ... ولكن الأقرب الذي يمكنني التفكير فيه هو استخدام وقت Joda (كما هو موضح في هذا المنشور: كيفية حساب الوقت المنقضي من الآن مع وقت جودا؟
هذا رمز أفضل إذا نظرنا في الأداء. إنه يقلل من عدد الحسابات.سببيتم حساب الدقائق فقط إذا كان عدد الثواني أكبر من 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;
}
}
لأجهزة الأندرويدكما قال رافي بالضبط ، ولكن بما أن الكثير من الناس يرغبون في ذلك فقط نسخ لصق الشيء هنا هو.
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("");
}
شرح للأشخاص الذين لديهم المزيد من الوقت
- تحصل على البيانات من مكان ما. أولاً عليك معرفة تنسيقه.
السابق. أحصل على البيانات من خادم بالتنسيق ، 27 يناير 2016 09:32:35 بتوقيت جرينتش [ربما لم تكن هذه حالتك
يتم ترجمة هذا إلى
SimpleDateFormat formatter = new SimplEdateFormat ("EEE ، DD MMM YYYY HH: MM: SS Z") ؛
كيف أعرف ذلك؟ إقرأ ال الوثائق هنا.
ثم بعد تحليله ، أحصل على موعد. هذا التاريخ الذي وضعته في getRelativetimesPanstring (بدون أي معلمات إضافية يكون على ما يرام من قبلي ، لأكون افتراضيًا إلى دقائق)
ستحصل على استثناء إذا لم تكتشف سلسلة التحليل الصحيحة, ، شيء مثل: استثناء في الشخصية 5. انظر إلى الحرف 5 ، وقم بتصحيح سلسلة التحليل الأولية.. قد تحصل على استثناء آخر ، كرر هذه الخطوات حتى تحصل على الصيغة الصحيحة.
ها هو تنفيذ هذا جافا لهذا
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();
}
}
إنه يعمل بالنسبة لي
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;
} }
هذا هو البرنامج النصي الأساسي للغاية. من السهل التحسين.
النتيجة: (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>
لهذا فعلت Just Now, seconds ago, min ago, hrs ago, days ago, weeks ago, months ago, years ago في هذا المثال ، يمكنك تحليل التاريخ مثل 2018-09-05T06:40:46.183Z هذا أو أي آخر مثل أدناه
أضف القيمة أدناه في 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>
رمز Java حاول أدناه
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;
}
يمكنك استخدام مكتبة جافا 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"
أنا أستخدم الفوري والتاريخ و DateTimeUtils. البيانات (التاريخ) التي يتم تخزينها في قاعدة البيانات في نوع السلسلة ومن ثم التحويل لتصبح فورية.
/*
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
ال الجواب من قبل Habsq لديه الفكرة الصحيحة ولكن الأساليب الخاطئة.
لمدى الوقت غير مرتبط بالجدول الزمني على نطاق أيام الشهر ، استخدم Period. لعدة أيام ، تعني أجزاء على مدار 24 ساعة من الوقت غير ذي صلة بالتقويم وساعات الساعات الثانية ، والاستخدام Duration. خلط المقياسين نادرا ما يكون له أي معنى.
Duration
ابدأ بجلب اللحظة الحالية كما هو موضح في التوقيت العالمي, ، باستخدام 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 );
بناء سلسلة من القطع "time ago".
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.
لمعرفة المزيد ، انظر تعليمي أوراكل. والبحث في سعة مكدس للعديد من الأمثلة والتفسيرات. المواصفات JSR 310.
ال وقت جودا مشروع ، الآن في نمط الصيانة, ، ينصح بالهجرة إلى Java.Time الطبقات.
يمكنك التبادل Java.Time الكائنات مباشرة مع قاعدة البيانات الخاصة بك. إستخدم سائق JDBC متوافق مع JDBC 4.2 أو لاحقا. لا حاجة للسلاسل ، لا حاجة ل java.sql.* الطبقات.
من أين تحصل على فصول java.time؟
- Java SE 8, Java SE 9, Java SE 10, Java SE 11, ، وبعد ذلك - جزء من واجهة برمجة تطبيقات Java القياسية مع تنفيذ مجمعة.
- يضيف Java 9 بعض الميزات والإصلاحات البسيطة.
- Java SE 6 و Java SE 7
- أكثر من Java.Time تم تشغيل الوظيفة إلى Java 6 و 7 In Threeten-Backport.
- ذكري المظهر
- إصدارات لاحقة من تطبيقات حزمة Android من Java.Time الطبقات.
- لنظام Android في وقت سابق (<26) ، Threetenabp يتكيف المشروع Threeten-Backport (المذكور أعلاه). نرى كيفية استخدام threetenabp ....
ال Threeten-extra يمتد المشروع Java.time مع فصول إضافية. هذا المشروع هو أرضية إثبات للإضافات المستقبلية المحتملة إلى Java.time. قد تجد بعض الفصول المفيدة هنا مثل Interval, YearWeek, YearQuarter, ، و أكثر.
هذه الوظيفة ستحسبها في جافا النقية ، ومع ذلك ، فإن هذه الوظيفة لا تظهر الجزئية مثل "1 hour, 3 minutes", ، سوف يستخدم أكبر قيمة للحاوية (ساعات ، أيام ، أشهر ، إلخ) يمكنها ، وتدور إلى أقرب قيمة.
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" : "");
}
}
