জাভাতে "সময় আগে" গণনা কিভাবে?

127

রুবেল অন রেলে, এমন একটি বৈশিষ্ট্য রয়েছে যা আপনাকে কোনও তারিখ নিতে এবং এটি "অনেক আগে" কী ছিল তা মুদ্রণ করতে দেয়।

উদাহরণ স্বরূপ:

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

জাভাতে এটি করার কোনও সহজ উপায় আছে?

java  date  time  datediff  relative-time-span 
— jts
সূত্র
1
দেখুন: stackoverflow.com/questions/11/how-do-i-calculate-relative- সময় এটি সি #, তবে আমি নিশ্চিত যে আপনি এটিকে সামান্য সমস্যায় রূপান্তর করতে পারবেন।
— ব্র্যান্ডন 21

উত্তর:

177

কটাক্ষপাত 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.text.format.DateUtilsশ্রেণিতে নির্মিত হয়েছে ।

— ataylor
সূত্র
229
আপনি যদি অ্যান্ড্রয়েডে কাজ করছেন তবে আপনি এটি ব্যবহার করতে পারেন: android.text.format.DateUtils # getRelativeTimeSpanString ()
— সোমটিক
আপনি কি দয়া করে আপনার উত্তরে আরও কিছু বিবরণ যুক্ত করতে পারেন, কেবলমাত্র লিঙ্কের উত্তরটি আপাতত ভাল নয়।
— অজয়
@ সোমটিক যদি আপনার অ-অ্যান্ড্রয়েড প্ল্যাটফর্মে এটি পেতে হয় তবে আপনি এই ক্লাসটি এওএসপিতে দেখতে পারেন ।
— greg7gkb
@ataylor কীভাবে অ্যান্ড্রয়েডে এই ব্যবহার ??
— হার্দিক পারমার
getRelativeTimeSpanString সকল পরিস্থিতিতে আদর্শ নয় এবং সে কারণেই আমি এখানে প্রচুর উদাহরণের উপর ভিত্তি করে আমার নিজস্ব শ্রেণি তৈরি করেছি। : নীচের আমার সমাধান দেখুন stackoverflow.com/a/37042254/468360
— Codeversed
67

আপনি কি টাইম ইউনাইট এনাম বিবেচনা করেছেন ? এই ধরণের জিনিসটির জন্য এটি বেশ কার্যকর হতে পারে

    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();
    }
— বেন জে
সূত্র
4
সময় ইউনিটগুলি স্বতন্ত্র থাকায় আমি এটি একটি সম্পূর্ণ উত্তর বলে মনে করি না। উদাহরণস্বরূপ - মিলি সেকেন্ড সময় মাত্র মিনিট সময় * 60 * 1000 You "সময় পূর্বে এটি ব্যবহার করতে সক্ষম হওয়ার জন্য আপনাকে পরবর্তী সময়ের বড় ইউনিট (এটি নিম্ন সময়ের ইউনিটে রূপান্তর করার পরে) থেকে হ্রাস করতে হবে in "স্ট্রিং।
— নাটিভ
@ বেঞ্জ - ঠিক আছে? সমাধানের উপরে? কারণ এক সময় 12 ঘন্টা ফর্ম্যাটে এবং অন্য সময়টি 24 ঘন্টা বিন্যাসে। আমার প্রশ্নের জন্য আপনার প্রতিক্রিয়া আমাকে জানান। অগ্রিম আপনাকে ধন্যবাদ।
— সুইফট
যদিও এটি ভুল ... প্রতিটি ইউনিট ইতিমধ্যে উল্লিখিত মত পৃথক পৃথক থেকে পৃথক।
— জোনাথন লালিবার্তে
1
অ্যান্ড্রয়েড এটি আপনার জন্য করে আপনি যদি অ্যান্ড্রয়েডে কাজ করছেন তবে আপনি এটি ব্যবহার করতে পারেন: android.text.format.DateUtils.getRelativeTimeSpanString (মিলিসেকেন্ড)
— ওয়াজিদ আলী
50

আমি রিয়েলহটো এবং বেন জে উত্তরগুলি গ্রহণ করি এবং নিজের সংস্করণটি তৈরি করি:

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
— রিকার্ডো ক্যাসাটা
সূত্র
সত্যিই ঠাণ্ডা. এবং সপ্তাহের মতো অন্যান্য সময় ইউনিট যুক্ত করা সত্যিই সহজ
— পিওটার
1
এই এক আরও upvotes প্রাপ্য। প্রথমত, কোনও গ্রন্থাগারের প্রয়োজন নেই। এটি এখনও পরিষ্কার, মার্জিত এবং পরিবর্তনযোগ্য।
— fangzhzh
ছোট টাইপো: আপনার কোডের অভ্যন্তরে আপনি "সময়আগো" এর পরিবর্তে স্থির বৈশিষ্ট্যগুলি "তালিকাগুলি" উল্লেখ করছেন re তালিকা.টাইম.জেট (i) সময়আগো.জেট হওয়া উচিত (i) ... এবং আরও কিছু
— ডায়োগো গোমেস
2
সামান্য পরামর্শ: 0 এর .append(temp != 1 ? "s" : "")পরিবর্তে ব্যবহার করুন .append(temp > 1 ? "s" : "")s
— কারণটির
1
@ শাজিলআফজাল হ্যাঁ, সময়কাল প্যারামিটারটি মিলিসেকেন্ডে তবে এটি একটি পার্থক্যের সাথে পার্থক্য নয় যা একেবারে সম্পূর্ণ মূল্য নয়। আপনি যা পাচ্ছেন তা হ'ল সময়টি 1 ই জানুয়ারী 1970 থেকে যে তারিখটি ইউনিক্স টাইমস্ট্যাম্প শুরু হয়েছিল
— রিকার্ডো ক্যাসাটা
42 
  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
সূত্র
আমি এর একটি সংশোধিত সংস্করণ ব্যবহার করে শেষ করেছি। আপনার জন্য আমার রিভিশন পোস্ট।
— ডেভিড ব্ল্যুইন্স
5
ডেভিড Blevins, PrettyTime সম্পর্কে আরো উদাহরণ: stackoverflow.com/questions/3859288/... বিগ -1 আরো একবার এবং চাকা reinventing 3 য় পক্ষের গ্রন্থাগার :-p সুপারিশ জন্য
— zakmck
9

এটি রিয়েলহটোটির উত্তরের উপর ভিত্তি করে তৈরি করা তাই যদি আপনি এটি পছন্দ করেন তবে তাকে / তাকে কিছুটা ভালবাসাও দিন।

এই পরিষ্কার করা সংস্করণ আপনাকে আপনার আগ্রহী হতে পারে এমন সময়সীমা নির্দিষ্ট করার অনুমতি দেয়।

এটি "এবং" অংশটি কিছুটা আলাদাভাবে পরিচালনা করে। আমি প্রায়শই একটি ডিলিমিটারের সাথে স্ট্রিংগুলিতে যোগদান করার সময় জটিল যুক্তি এড়ানো সহজ এবং শেষ হয়ে গেলে শেষ ডিলিমিটার মুছে ফেলা সহজ।

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

এবং যদি কারও কারও কাছে এটির প্রয়োজন হয়, এখানে একটি শ্রেণি রয়েছে যা উপরের মত যে কোনও স্ট্রিংটিকে মিলি সেকেন্ডে রূপান্তর করবে । লোকেরা পাঠযোগ্য পাঠ্যে বিভিন্ন জিনিসের টাইমআউট নির্দিষ্ট করার জন্য এটি বেশ কার্যকর।

— ডেভিড ব্লিভিনস
সূত্র
9

এটি করার একটি সহজ উপায় আছে:

যাক আপনি 20 মিনিট আগে সময় চান:

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

এটাই..

— Moria
সূত্র
1
বেশিরভাগ ক্ষেত্রে, আপনি একটি "স্মার্ট" প্রদর্শন, অর্থাত্ চাই। 5125 মিনিট আগে এর পরিবর্তে, আপনি x দিন আগে বলেছিলেন।
— ফিলিহো
7

বিল্ট-ইন সমাধান সম্পর্কে :

জাভা-তে আপেক্ষিক সময়ে বিন্যাসের জন্য কোনও অন্তর্নির্মিত সমর্থন নেই, জাভা -৮ এবং এর নতুন প্যাকেজটিও নয় java.time। আপনার যদি কেবল ইংরেজী দরকার হয় এবং তারপরে এবং কেবল তখনই একটি হাতে তৈরি সমাধান গ্রহণযোগ্য হতে পারে - @ রিয়েলহটোটির উত্তর দেখুন (যদিও স্থানীয় সময়ে তাত্ক্ষণিক ডেল্টাস অনুবাদ করার সময়সীমাটি বিবেচনায় না নেওয়ার প্রবল অসুবিধা রয়েছে ইউনিট!)। যাইহোক, যদি আপনি বিশেষত অন্যান্য লোকেলের জন্য বাড়ির-বিকাশযুক্ত জটিল কাজগুলি এড়াতে চান তবে আপনার একটি বাহ্যিক গ্রন্থাগার প্রয়োজন।

পরবর্তী ক্ষেত্রে, আমি আমার লাইব্রেরি টাইম 4 জ (অথবা Android এ টাইম 4 এ) ব্যবহার করার পরামর্শ দিই । এটি সর্বাধিক নমনীয়তা এবং সর্বাধিক আই 18 এন-পাওয়ার সরবরাহ করে । ক্লাস নেট.টাইম 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 টি ভাষা এবং কিছু দেশ-নির্দিষ্ট লোকেল (বিশেষত স্প্যানিশ, ইংরেজি, আরবী, ফরাসী ভাষায়) সমর্থন করে। আই 18 এন- ডেটা মূলত নতুন সিএলডিআর-সংস্করণ v29 এর উপর ভিত্তি করে । এই লাইব্রেরিটি কেন ব্যবহার করার অন্যান্য গুরুত্বপূর্ণ কারণগুলি হ'ল বহুবচন নিয়মের (যা প্রায়শই অন্যান্য স্থানীয় অবস্থানের তুলনায় ইংরেজি থেকে আলাদা) সংক্ষিপ্ত বিন্যাস শৈলী (উদাহরণস্বরূপ: "1 সেকেন্ড পূর্বে") এবং অ্যাকাউন্টের সময় অঞ্চল বিবেচনার জন্য বহনকারী উপায়গুলির পক্ষে ভাল সমর্থন । টাইম 4 জে এমনকি আপেক্ষিক সময়ের গণনায় লিপ সেকেন্ডের মতো বিদেশী বিশদ সম্পর্কে অবগত (সত্যই গুরুত্বপূর্ণ নয় তবে এটি প্রত্যাশা দিগন্তের সাথে সম্পর্কিত একটি বার্তা গঠন করে)। জাভা-8 সাথে সামঞ্জস্যেরjava.time.Instantবা এর মতো ধরণের জন্য সহজেই রূপান্তর পদ্ধতির কারণে বিদ্যমান java.time.Period।

কোন ত্রুটি আছে? মাত্র দুই.

  • গ্রন্থাগারটি ছোট নয় (এটির বড় আই 18 এন-ডেটা সংগ্রহস্থলের কারণেও)।
  • API টি তেমন পরিচিত নয় তাই সম্প্রদায়ের জ্ঞান এবং সমর্থন এখনও পাওয়া যায় নি অন্যথায় সরবরাহ করা ডকুমেন্টেশন বেশ বিশদভাবে এবং ব্যাপক।

(কমপ্যাক্ট) বিকল্প:

আপনি যদি আরও ছোট সমাধানের সন্ধান করেন এবং এতগুলি বৈশিষ্ট্যের প্রয়োজন নেই এবং আই 18 এন-ডেটা সম্পর্কিত সম্ভাব্য মানের সমস্যাগুলি সহ্য করতে রাজি হন তবে:

  • আমি অকপসফট / প্রাইটিটাইম ( java.util.Dateকেবলমাত্র সাথে কাজের জন্য উপযুক্ত 32 টি ভাষা (শীঘ্রই 34?) সমর্থন করার জন্য প্রস্তাব দিচ্ছি - @ অ্যাটেলারের উত্তর দেখুন)। শিল্পের মানক সিএলডিআর (ইউনিকোড কনসোর্টিয়াম থেকে) এর বৃহত সম্প্রদায়ের পটভূমিটি দুর্ভাগ্যবশত আই 18 এন-ডেটার ভিত্তি নয় তাই আরও বর্ধিতকরণ বা ডেটা উন্নতি করতে কিছুটা সময় নিতে পারে ...

  • আপনি যদি অ্যান্ড্রয়েডে থাকেন তবে সহায়ক শ্রেণীর android.text.format.DateUtils একটি স্লিম অন্তর্নির্মিত বিকল্প (অন্যান্য মন্তব্য এবং উত্তরগুলি এখানে দেখুন, অসুবিধার সাথে যে এটি বছর এবং মাস ধরে সমর্থন করে না। এবং আমি নিশ্চিত যে কেবলমাত্র খুব কম লোক এই সহায়ক শ্রেণীর এপিআই-স্টাইল পছন্দ করে।

  • আপনি যদি জোদা-সময়ের অনুরাগী হন তবে আপনি এর ক্লাস পিরিওডফর্ম্যাটটি দেখতে পারেন (অন্যদিকে রিলিজ v2.9.4-এ 14 টি ভাষা সমর্থন করুন: জোদা-সময় অবশ্যই কমপ্যাক্ট নয়, তাই আমি এখানে এটি উল্লেখ করেছি কেবলমাত্র সম্পূর্ণতার)। এই লাইব্রেরিটি আসল উত্তর নয় কারণ আপেক্ষিক সময়গুলি মোটেই সমর্থিত নয়। আপনাকে অন্তত আক্ষরিক "পূর্বে" সংযোজন করতে হবে (এবং উত্পন্ন তালিকা বিন্যাসগুলি - বিশ্রী থেকে ম্যানুয়ালি সমস্ত নিম্ন ইউনিটগুলি সরিয়ে ফেলতে হবে)। টাইম 4 জ বা অ্যান্ড্রয়েড-ডেট ইউটিলসের বিপরীতে, সংক্ষিপ্ত বিবরণগুলি বা আপেক্ষিক সময় থেকে নিখুঁত সময়ের উপস্থাপনায় স্বয়ংক্রিয়ভাবে স্যুইচ করার জন্য এর কোনও বিশেষ সমর্থন নেই। প্রাইটিটাইমের মতো এটি সম্পূর্ণরূপে জাভা-সম্প্রদায়ের ব্যক্তিগত আইডিআইএন-এর ডেটা-র অনাকাঙ্খিত অবদানের উপর নির্ভরশীল।

— মেনো হচসচাইল্ড
সূত্র
5

আপনি যদি কোনও সাধারণ "আজ", "গতকাল" বা "x দিন আগে" খুঁজছেন।

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";
}
— ডুমি জে
সূত্র
5

java.time

জাভা 8 টাইম ফ্রেমওয়ার্কটি জাভা 8 এবং তার পরে নির্মিত Using

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");
— habsq
সূত্র
1
এই Durationপদ্ধতিগুলি পুরো সময়কালকে মোট ঘন্টা এবং মোট মিনিটের সংখ্যা হিসাবে প্রতিবেদন করে । জাভা 8-এ ক্লাসের অদ্ভুতভাবে ঘন্টা এবং মিনিট এবং সেকেন্ডের প্রতিটি অংশ পাওয়ার জন্য কোনও পদ্ধতির অভাব ছিল । জাভা 9 এই পদ্ধতিগুলি নিয়ে আসে to…Part,।
— বাসিল বাউর্ক
4

আপনি যদি অ্যান্ড্রয়েডের জন্য কোনও অ্যাপ্লিকেশন বিকাশ করে থাকেন তবে এ জাতীয় সমস্ত প্রয়োজনীয়তার জন্য এটি ইউটিলিটি ক্লাস ডেট ইউটিস সরবরাহ করে । ডেট ইউটিলস # getRelativeTimeSpanString () ইউটিলিটি পদ্ধতিটি দেখুন।

দস্তাবেজ থেকে

CharSequence getRelativeTimeSpanString (দীর্ঘ সময়, এখন দীর্ঘ, দীর্ঘ মিনিট সমাধান)

'সময়' কে 'এখন' এর সাথে সম্পর্কিত সময়ের হিসাবে বর্ণনা করে একটি স্ট্রিং দেয় Return অতীতে সময়ের স্প্যান্সগুলি "42 মিনিট আগে" এর মতো ফর্ম্যাট করা হয়। ভবিষ্যতে সময়ের স্প্যানগুলি "42 মিনিটে" এর মতো ফর্ম্যাট হয়।

তুমি তোমার ক্ষণস্থায়ী হবে timestampযেমন সময় এবং System.currentTimeMillis()যেমন এখন । minResolutionআপনি সর্বনিম্ন timespan প্রতিবেদন করতে উল্লেখ করতে দেয়।

উদাহরণস্বরূপ, অতীতে একটি সময় 3 সেকেন্ডের জন্য "0 মিনিট আগে" হিসাবে রিপোর্ট করা হবে যদি এটি MINUTE_IN_MILLIS এ সেট করা থাকে। 0, MINUTE_IN_MILLIS, HOUR_IN_MILLIS, DAY_IN_MILLIS, WEEK_IN_MILLIS ইত্যাদির মধ্যে একটি পাস করুন

— রবি থাপলিয়াল
সূত্র
4

আপনি সময় পূর্বে গণনা করতে এই ফাংশনটি ব্যবহার করতে পারেন

 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) এখানে টাইম_গো মাইক্রোসেকেন্ডে রয়েছে

— রাজেশ তিওয়ারি
সূত্র
4

এখানে প্রচুর উত্তরের ভিত্তিতে আমি আমার ব্যবহারের ক্ষেত্রে নিম্নলিখিতটি তৈরি করেছি।

ব্যবহারের উদাহরণ:

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();
    }
}
— Codeversed
সূত্র
এটি খুব দরকারী, আপনাকে অনেক ধন্যবাদ।
— হায়া আক্কাদ
3

Joda টাইম প্যাকেজ, ধারণা হয়েছে সময়কাল । আপনি পিরিয়ডস এবং ডেটটাইমস সহ পাটিগণিত করতে পারেন।

ডক্স থেকে :

public boolean isRentalOverdue(DateTime datetimeRented) {
  Period rentalPeriod = new  Period().withDays(2).withHours(12);
  return datetimeRented.plus(rentalPeriod).isBeforeNow();
}
— পল রুবেল
সূত্র
2

যদি আমরা পারফরম্যান্স বিবেচনা করি তবে এটি আরও ভাল কোড। এটি গণনার সংখ্যা হ্রাস করে। কারণগুলির মিনিটগুলি তখনই গণনা করা হয় যদি সেকেন্ডের সংখ্যা 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";
                            }
                        }
                    }
                }
            }
        }
    }

}

}
— আসাদ মির্জা
সূত্র
1
আপনি যদি অ্যান্ড্রয়েডে কাজ করছেন তবে আপনি এটি ব্যবহার করতে পারেন: android.text.format.DateUtils.getRelativeTimeSpanString (মিলিসেকেন্ড)
— ওয়াজিদ আলী
2

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

"সময় আগে" টুকরাগুলির স্ট্রিং তৈরি করুন।

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 ফ্রেমওয়ার্ক জাভা 8 এবং পরে পাতাটা করা হয়। এই ক্লাসগুলি , & , এর মতো সমস্যাযুক্ত পুরানো উত্তরাধিকারের তারিখ-সময়ের ক্লাসগুলিকে সহায়তা করে ।java.util.DateCalendarSimpleDateFormat

আরও জানতে, ওরাকল টিউটোরিয়ালটি দেখুন । এবং অনেক উদাহরণ এবং ব্যাখ্যার জন্য স্ট্যাক ওভারফ্লো অনুসন্ধান করুন। স্পেসিফিকেশনটি জেএসআর 310 ।

Joda-টাইম প্রকল্প, এখন রক্ষণাবেক্ষণ মোড , মাইগ্রেশনে উপদেশ java.time ক্লাস।

আপনি আপনার ডাটাবেসের সাথে জাভা.টাইম অবজেক্টগুলি সরাসরি বিনিময় করতে পারেন । জেডিবিসি ৪.২ বা তারপরের সাথে অনুগত একটি জেডিবিসি ড্রাইভার ব্যবহার করুন । স্ট্রিংগুলির দরকার নেই, ক্লাসের প্রয়োজন নেই ।java.sql.*

জাভা.টাইম ক্লাস কোথায় পাবেন?

ThreeTen-অতিরিক্ত প্রকল্প অতিরিক্ত শ্রেণীর সাথে java.time প্রসারিত করে। এই প্রকল্পটি জাভা.টাইমে সম্ভাব্য ভবিষ্যতের সংযোজনগুলির একটি প্রমাণযোগ্য ক্ষেত্র। আপনি এখানে কিছু দরকারী শ্রেণীর যেমন খুঁজে পেতে পারেন Interval, YearWeek, YearQuarter, এবং আরো ।

— তুলসী বাউরক
সূত্র
তোমাকে অনেক ধন্যবাদ!
— টিকারহাজ
1

দীর্ঘ গবেষণার পরে আমি এটি খুঁজে পেয়েছি।

    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;
    }
}
— হরি কৃষ্ণ অন্ধ্র প্রদেশ
সূত্র
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 9:32:35 GMT ফর্ম্যাটে একটি সার্ভার থেকে ডেটা পেয়েছি [এটি সম্ভবত আপনার ক্ষেত্রে নয়]

এটি অনুবাদ করা হয়

সিম্পলডেট ফরমেট ফর্ম্যাটার = নতুন সিম্পলডেট ফরমেট ("EEE, dd এমএমএম yyyy এইচ এইচ: মিমি: এসএস জেড");

আমি এটা কিভাবে জানি? ডকুমেন্টেশন এখানে পড়ুন ।

তারপরে পার্স করার পরে আমি একটি তারিখ পাই। সেই তারিখটি আমি getRelativeTimeSpanString এ রেখেছি (কোনও অতিরিক্ত পরামিতি ছাড়াই আমার ঠিক আছে, মিনিটে ডিফল্ট হতে হবে)

আপনি যদি সঠিক পার্সিং স্ট্রিংটি খুঁজে না পান তবে আপনি একটি ব্যতিক্রম পাবেন , এর মতো কিছু: চরিত্র 5 এ ব্যতিক্রম । 5 অক্ষরটি দেখুন এবং আপনার প্রাথমিক পার্সিংয়ের স্ট্রিংটি সংশোধন করুন। । আপনি অন্য একটি ব্যতিক্রম পেতে পারেন, সঠিক সূত্র না পাওয়া পর্যন্ত এই পদক্ষেপগুলি পুনরাবৃত্তি করুন।

— OWADVL
সূত্র
1 
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"
    }
}

}

কল

ভাল স্ট্রিং = সময়আগো (ইউনিক্সটাইমস্ট্যাম্প)

কোটলিনে সময় আগে পেতে

— দিনো সানি
সূত্র
0

এটি আমার জাভা বাস্তবায়ন এখানে

    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();
    }
  }
— জোই পিন্টো
সূত্র
0

এটা আমার জন্য কাজ করে

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;
    } }
— রাহুল
সূত্র
0

এটি খুব বেসিক লিপি। এটি উন্নত করা সহজ।
ফলাফল: (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>
— দ্বিপা আরন্ত
সূত্র
0

এর জন্য আমি Just Now, seconds ago, min ago, hrs ago, days ago, weeks ago, months ago, years agoএই উদাহরণটিতে করেছি আপনি তারিখটি পার্স করতে পারেন2018-09-05T06:40:46.183Z নীচের মত বা অন্য কোনও

স্ট্রিং.এক্সএমএলে নীচে মান যুক্ত করুন

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

জাভা কোড নীচে চেষ্টা করুন

  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;
    }
— OmiK
সূত্র
আপনি যদি অ্যান্ড্রয়েডে কাজ করছেন তবে আপনি এটি ব্যবহার করতে পারেন: android.text.format.DateUtils.getRelativeTimeSpanString (মিলিসেকেন্ড)
— ওয়াজিদ আলী
0

আপনি জাভার লাইব্রেরি ব্যবহার করতে পারেন রিলেটিভডেটটাইম ফর্ম্যাটার , এটি ঠিক তা করে:

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"
— mavesonzini
সূত্র
1
এটি একটি অ্যান্ড্রয়েড লাইব্রেরি, জাভা লাইব্রেরি নয়।
— ম্যাডব্রেকস
0

আমি তাত্ক্ষণিক, তারিখ এবং তারিখের সময় ব্যবহার করছি। ডেটা (তারিখ) যা স্ট্রিংয়ের ধরণের ডাটাবেসে সংরক্ষণ করা হয় এবং তারপরে তাত্ক্ষণিক হয়ে রূপান্তরিত হয়।

    /*
    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;
    }
— Ticherhaz
সূত্র
1
আপনি ভয়াবহ পুরানো তারিখের সময় ক্লাসগুলি ব্যবহার করছেন যা জাভা.টাইম ক্লাসগুলি দ্বারা বহু বছর আগে অনুমান করা হয়েছিল ।
— তুলসী বার্ক
@ বাসিলবার্ক আমি এখনও এটি করার সর্বশেষ উপায় খুঁজে পাচ্ছি না।
— টিকারহাজ
@ বাসিলবার্ক এটি বুঝতে আমার জন্য কিছু কোড যুক্ত করেছি। github.com/ticherhaz/tarikhmasa
— টেরহাজ
0

নিম্নলিখিত সমাধানগুলি সমস্ত খাঁটি জাভাতে রয়েছে:

বিকল্প 1: গোলাকার নয় এবং কেবলমাত্র বৃহত্তম সময় ধারক

নিম্নলিখিত ফাংশনটি কেবলমাত্র বৃহত্তম সময় ধারক প্রদর্শন করবে, উদাহরণস্বরূপ, যদি সত্য সময় অতিবাহিত হয় "1 month 14 days ago" এই ফাংশনটি কেবল প্রদর্শিত হবে "1 month ago"। এই ফাংশনটি সর্বদা গোল হয়ে যায়, সুতরাং এর সমতুল্য সময়টি "50 days ago"প্রদর্শিত হবে display"1 month"

public String formatTimeAgo(long millis) {
        String[] ids = new String[]{"second","minute","hour","day","month","year"};

        long seconds = millis / 1000;
        long minutes = seconds / 60;
        long hours = minutes / 60;
        long days = hours / 24;
        long months = days / 30;
        long years = months / 12;

        ArrayList<Long> times = new ArrayList<>(Arrays.asList(years, months, days, hours, minutes, seconds));

        for(int i = 0; i < times.size(); i++) {
            if(times.get(i) != 0) {
                long value = times.get(i).intValue();

                return value + " " + ids[ids.length - 1 - i] + (value == 1 ? "" : "s") + " ago";
            }
        }

        return "0 seconds ago";
    }

বিকল্প 2: বৃত্তাকার সহ

কেবলমাত্র রাউন্ডে সময় ধারক আপনি একটি Math.round (...) বিবৃতি দিয়ে বৃত্তাকার চাই মোড়ানো, তাই যদি আপনি চেয়েছিলেন 50 daysকরতে 2 months, সংশোধন long months = days / 30করতেlong months = Math.round(days / 30.0)

— wdavies973
সূত্র
1
ব্যবহার Durationতার সঙ্গে to…Partযেমন দেখানো পদ্ধতি অনেক সহজ হবে, আমার উত্তর ।
— বেসিল Bourque
0

এখানে আমার পরীক্ষার কেস, আশা করি এটি সহায়তা করবে:

    val currentCalendar = Calendar.getInstance()
    currentCalendar.set(2019, 6, 2, 5, 31, 0)

    val targetCalendar = Calendar.getInstance()
    targetCalendar.set(2019, 6, 2, 5, 30, 0)

    val diffTs = currentCalendar.timeInMillis - targetCalendar.timeInMillis
    val diffMins = TimeUnit.MILLISECONDS.toMinutes(diffTs)
    val diffHours = TimeUnit.MILLISECONDS.toHours(diffTs)
    val diffDays = TimeUnit.MILLISECONDS.toDays(diffTs)
    val diffWeeks = TimeUnit.MILLISECONDS.toDays(diffTs) / 7
    val diffMonths = TimeUnit.MILLISECONDS.toDays(diffTs) / 30
    val diffYears = TimeUnit.MILLISECONDS.toDays(diffTs) / 365

    val newTs = when {
        diffYears >= 1 -> "Years $diffYears"
        diffMonths >= 1 -> "Months $diffMonths"
        diffWeeks >= 1 -> "Weeks $diffWeeks"
        diffDays >= 1 -> "Days $diffDays"
        diffHours >= 1 -> "Hours $diffHours"
        diffMins >= 1 -> "Mins $diffMins"
        else -> "now"
    }
— David_Wang
সূত্র
1
জেএসআর 310 গ্রহণের সাথে Calendarআধুনিক জাভা.টাইম ক্লাসগুলি দ্বারা কয়েক বছর আগে ভয়ানক শ্রেণিটি দমন করা হয়েছিল । 2019. মধ্যে দরিদ্র পরামর্শ
— বেসিল Bourque
আপনি অবশ্যই বোঝাতে চেয়েছিলেন var, না val।
— বেসিল Bourque
0

GetrelativeDateTime ফাংশন হিসাবে আপনি 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();
}
— সুমিত সিং
সূত্র
অবদান রাখতে চাওয়ার জন্য ধন্যবাদ এটি ঠিক যা বলা হয়েছিল তা নয়, তবে সম্ভবত কেউ এটি ব্যবহার করতে পারেন। যদিও কেউ বা অন্য কারও ব্যবহার করতে চান না SimpleDateFormatএবং Calendar, যদিও। এই ক্লাসগুলি খারাপভাবে ডিজাইন করা এবং দীর্ঘ পুরানো are পরিবর্তে java.time, আধুনিক জাভা তারিখ এবং সময় এপিআই নিয়োগ করে এমন উত্তরগুলি পড়ুন।
— ওলে ভিভি
0

সরলতা এবং আপডেট হওয়া প্রতিক্রিয়ার অভাবের জন্য, আরও সাম্প্রতিক জাভা 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));
    }
}

এটি সেই সংস্করণ যা জাভা টাইম এপিআই ব্যবহার করে যা তারিখ এবং সময় নিয়ে কাজ করার জন্য অতীত থেকে সমস্যাগুলি সমাধান করার চেষ্টা করে।

Javadoc

সংস্করণ 8 https://docs.oracle.com/javase/8/docs/api/index.html?java/time/package-summary.html

সংস্করণ 11 https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/package-summary.html

ডাব্লু 3 স্কুলস টিউটোরিয়াল - https://www.w3schools.com/java/java_date.asp

ডি জোন নিবন্ধ - https://dzone.com/articles/java-8-date-and-time time

— brunocrt
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.