दिलचस्प पोस्ट
एचटीएमएल / सीएसएस के साथ मैं बराबर ऊँचाई div (किनारे की तरफ) कैसे प्राप्त करूं? अगर / अन्य बयानों के अंदर कार्य घोषणाएं हैं? ओपनसीवी सी ++ / ओबीजे-सी: उन्नत वर्ग पहचान एंड्रॉइड एक्शन बार अतिप्रवाह नहीं दिखा रहा है कैसे डिफ़ॉल्ट विषय में ActionBar के केंद्र में शीर्षक संरेखित करें (Theme.Holo.Light) एंड्रॉइड के लिए एक्लिप्स में लॉजसीट / कंसोल को कैसे सक्षम करें? UITableView dequeueReusableCellWithIdentifier थ्योरी Android ऐप्लिकेशन में क्रेडेंशियल्स (पासवर्ड) को सुरक्षित रूप से कैसे स्टोर करें? अपरिचित SSL संदेश, सादा टेक्स्ट कनेक्शन? अपवाद कैसे variadic टेम्पलेट तर्कों को स्टोर करने के लिए? Ninject समर्थन Func (ऑटो उत्पन्न कारखाने) करता है? मैं सी # में यादृच्छिक अक्षरांकीय स्ट्रिंग कैसे उत्पन्न करूं? मॉलोक और कॉलोक के बीच का अंतर? जावास्क्रिप्ट के द्वारा HTML तत्व के बिना शुद्ध पाठ प्राप्त करें? आसानी से समय बीत चुका है

जावा में "समय पहले" की गणना कैसे करें?

रेल पर रूबी में, एक ऐसी सुविधा है जो आपको किसी भी तिथि लेने और प्रिंट करने का तरीका बताती है कि "बहुत पहले" कहां था।

उदाहरण के लिए:

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.text.format.DateUtilsandroid.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(); } 
  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 और बेन जे उत्तर लेते हैं और अपना खुद का संस्करण बनाते हैं:

 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 

यह 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); 

बस..

यदि आप एक साधारण "आज", "कल" ​​या "एक्स दिन पहले" की तलाश में हैं

 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

जावा 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"); 

अंतर्निहित समाधान के बारे में :

जावा में सापेक्ष समय के स्वरूपण के लिए कोई भी अंतर्निहित समर्थन नहीं है, यहां तक ​​कि जावा -8 और इसके नए पैकेज java.time अगर आपको केवल अंग्रेजी और कुछ और ही नहीं है और केवल तब ही हाथ से बने समाधान स्वीकार्य हो सकता है – @RealHowTo का जवाब देखें (हालांकि इसका तात्कालिक नुकसान स्थानीय स्तर पर तत्काल डेल्टा के अनुवाद के लिए समयक्षेत्र में नहीं लेना है इकाइयों!)। वैसे भी, यदि आप घर के उभरने वाले जटिल कामयाबों से विशेषकर अन्य स्थानों के लिए बचाना चाहते हैं, तो आपको एक बाहरी पुस्तकालय की आवश्यकता है।

बाद के मामले में, मैं अपने लाइब्रेरी टाइम 4 जे (या एंड्रॉइड पर टाइम 4 ए) का उपयोग करने की सलाह देता हूं। यह सबसे बड़ी लचीलेपन और सबसे i18n-power प्रदान करता है कक्षा नेट । टाइम 4 जे.प्रतिटाइम में सात तरीके 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-version v29 पर आधारित है। इस पुस्तकालय का उपयोग करने के अन्य महत्वपूर्ण कारण बहुवचन नियमों के लिए अच्छा समर्थन हैं (जो अक्सर अन्य स्थानीय भाषाओं में अंग्रेजी से भिन्न होते हैं), संक्षिप्त प्रारूप शैली (उदाहरण के लिए: "1 सेकंड पहले") और खाता समय-क्षेत्र में लेने के लिए अभिव्यंजक तरीके। टाइम 4 जे इस तरह के विदेशी विवरणों के बारे में भी सचेत हैं जैसे लीप सेकेंड में सापेक्ष समय की गणना (वास्तव में महत्वपूर्ण नहीं है लेकिन यह उम्मीद की क्षितिज से संबंधित संदेश बनाता है) Java- 8 के साथ संगतता जावा के प्रकारों के लिए आसानी से उपलब्ध रूपांतरण विधियों के कारण मौजूद है। java.time.Instant या java.time.Period

क्या कोई कमियां हैं? केवल दो।

  • पुस्तकालय छोटा नहीं है (इसकी बड़ी आई -18 एन-डेटा रिपॉजिटरी के कारण भी)
  • एपीआई अच्छी तरह से ज्ञात नहीं है, इसलिए समुदाय ज्ञान और समर्थन उपलब्ध नहीं हैं अन्यथा आपूर्ति की गई दस्तावेज़ीकरण बहुत विस्तृत और व्यापक है।

(कॉम्पैक्ट) विकल्प:

यदि आप एक छोटे समाधान की तलाश करते हैं और इतने सारे सुविधाओं की आवश्यकता नहीं है और i18n-data से संबंधित संभावित गुणवत्ता वाले मुद्दों को सहन करने के लिए तैयार हैं तो:

  • मैं ऑक्सफ़ोस्ट / प्रीटीटाइम (वास्तव में 32 भाषाओं के लिए समर्थन (जल्द ही 34?) java.util.Date के लिए काम करने के लिए उपयुक्त सुझाऊंगा।। केवल। – केवल @atealllor का उत्तर देखें)। इंडस्ट्री स्टैन्डर्ड सीएलडीआर (यूनिकोड कंसोर्टियम से) इसकी बड़ी समुदाय पृष्ठभूमि के साथ दुर्भाग्य से i18n- डेटा का आधार नहीं है, इसलिए आगे संवर्द्धन या डेटा के सुधार कुछ समय ले सकते हैं …

  • यदि आप एंड्रॉइड पर हैं तो सहायक क्लास एंड्रॉइड। टेक्स्ट। प्रारूप.डेटाइल्स एक स्लिम अंतर्निर्मित विकल्प है (अन्य टिप्पणियां और जवाब यहां देखें, इसका मतलब यह है कि इसका साल और महीनों के लिए कोई समर्थन नहीं है। और मुझे यकीन है कि केवल इस सहायक वर्ग की एपीआई शैली जैसी बहुत कम लोग।

  • यदि आप जोडा-टाइम का प्रशंसक हैं तो आप अपने क्लास पीरियडफॉर्मेट ( दूसरी भाषाओं में रिलीज v2.9.4 में 14 भाषाओं के लिए समर्थन देख सकते हैं: जोडा-टाइम निश्चित रूप से कॉम्पैक्ट नहीं है, इसलिए मैं इसे इसके लिए सिर्फ इसका उल्लेख करता हूं पूर्णता)। यह लाइब्रेरी एक वास्तविक उत्तर नहीं है क्योंकि सापेक्ष समय बिल्कुल समर्थित नहीं है। आपको कम से कम "पहले" शब्द को जोड़ना होगा (और मैन्युअल रूप से उत्पन्न होने वाले सभी निम्न इकाइयां जनरेटेड सूची प्रारूपों से अलग करना – अजीब)। टाइम 4 जे या एंड्रॉइड-डेट्यूल्ट्स के विपरीत, इसका संक्षेप या स्वत: स्विचिंग के लिए रिश्तेदार समय से निरपेक्ष समय के प्रतिनिधित्व के लिए कोई विशेष समर्थन नहीं है। प्रीटीटाइम की तरह, यह पूरी तरह से जावा-समुदाय के निजी सदस्यों के असंगत योगदान पर इसके i18n-डेटा के लिए निर्भर है।

मैंने jquery-timeago प्लग-इन का एक सरल जावा टाइमगो पोर्ट बनाया है जो आप के लिए पूछ रहे हैं।

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

जोडा-टाइम पैकेज में, अवधि की धारणा है। आप अंक और दिनांक समय के साथ अंकगणित कर सकते हैं।

डॉक्स से :

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

यह बहुत अच्छा नहीं है … लेकिन मैं जितना निकट सोच सकता हूँ, वो जोड-टाइम का उपयोग कर रहा है (जैसा कि इस पोस्ट में बताया गया है: अब से जोडा टाइम के साथ बीत चुके समय की गणना कैसे करें?

अगर आप एंड्रॉइड के लिए एक एप विकसित कर रहे हैं, तो यह ऐसी सभी आवश्यकताओं के लिए उपयोगिता वर्ग डेट्यूल्ट्स प्रदान करता है। DateUtils # getRelativeTimeSpanString () उपयोगिता विधि पर एक नज़र डालें

के लिए डॉक्स से

चरम सीमाएं प्राप्त करेंटाइलाइटटाइमस्पैनस्ट्रिंग (लंबे समय तक, लंबे समय तक, लंबे समय तक मिनरसोल्यूशन)

'अब' से संबंधित समय के रूप में 'समय' का वर्णन करने वाला स्ट्रिंग देता है। अतीत में समय सीमा "42 मिनट पहले" स्वरूपित होती है भविष्य में समय सीमा "42 मिनट में" स्वरूपित होती है

आप समय और System.currentTimeMillis() रूप में अपने timestamp गुजर रहे हैं अब के रूप में। minResolution आपको रिपोर्ट करने के लिए न्यूनतम minResolution निर्दिष्ट करने देता है।

उदाहरण के लिए, अतीत में 3 सेकंड का समय "0 मिनट पहले" के रूप में सूचित किया जाएगा यदि यह MINUTE_IN_MILLIS पर सेट किया गया है। 0, MINUTE_IN_MILLIS, HOUR_IN_MILLIS, DAY_IN_MILLIS, WEEK_IN_MILLIS आदि में से एक को पास करें।

लंबे शोध के बाद मैंने यह पाया।

  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; } } 

आप समय पहले की गणना करने के लिए इस फ़ंक्शन का उपयोग कर सकते हैं

  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) यहां टाइम_गो मायक्रोसेकंड में है

एंड्रॉइड के लिए वास्तव में रवी की तरह कहा, लेकिन बहुत से लोग सिर्फ इस चीज को कॉपी करके कॉपी करना चाहते हैं।

  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(""); } 

अधिक समय वाले लोगों के लिए स्पष्टीकरण

  1. आप कहीं से डेटा प्राप्त करते हैं पहले आपको इसे प्रारूप का पता लगाना होगा

पूर्व। मुझे प्रारूप में एक सर्वर से डेटा मिलता है बुध, 27 जनवरी 2016 09:32:35 GMT [यह शायद आपका मामला नहीं है]

इस में अनुवाद किया गया है

SimpleDateFormat formatter = नया सरलडेटफ़ॉर्मेट ("ईईई, डीडी एमएमएम याय एचएच: मिमी: एसएस जेड");

मैं इसे कैसे जानूं? यहां दस्तावेज पढ़ें ।

उसके बाद मुझे पार्स करने के बाद मुझे एक तारीख मिलती है। उस तिथि को मैं मिल गया रिलेटिव टाइम टाइम स्ट्रिंग (किसी भी अतिरिक्त पैरामीटर के बिना मेरे द्वारा ठीक है, मिनटों के लिए डिफ़ॉल्ट)

यदि आप सही पार्सिंग स्ट्रिंग का पता नहीं लगाए तो आपको अपवाद मिलेगा , कुछ ऐसा है: वर्ण 5 पर अपवाद चरित्र 5 को देखो, और अपनी प्रारंभिक पार्सिंग स्ट्रिंग को सही करें । आपको एक और अपवाद मिल सकता है, जब तक आपके पास सही सूत्र न हो तब तक इस चरण को दोहराएं।

यहां जवाबों के एक समूह के आधार पर, मैंने अपने उपयोग के मामले के लिए निम्नलिखित को बनाया है।

उदाहरण उपयोग:

 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(); } } 

यहां यह मेरा जावा कार्यान्वयन है I

  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>