জাভা 8: একাধিক ইউনিটে দুটি লোকালডেটটাইমের মধ্যে পার্থক্য


266

আমি উভয়ের মধ্যে পার্থক্য গণনা করার চেষ্টা করছি LocalDateTime

আউটপুটটি বিন্যাসের হওয়া দরকার y years m months d days h hours m minutes s seconds। আমি যা লিখেছি তা এখানে:

import java.time.Duration;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.Period;
import java.time.ZoneId;

public class Main {

    static final int MINUTES_PER_HOUR = 60;
    static final int SECONDS_PER_MINUTE = 60;
    static final int SECONDS_PER_HOUR = SECONDS_PER_MINUTE * MINUTES_PER_HOUR;

    public static void main(String[] args) {
        LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 9, 19, 46, 45);
        LocalDateTime fromDateTime = LocalDateTime.of(1984, 12, 16, 7, 45, 55);

        Period period = getPeriod(fromDateTime, toDateTime);
        long time[] = getTime(fromDateTime, toDateTime);

        System.out.println(period.getYears() + " years " + 
                period.getMonths() + " months " + 
                period.getDays() + " days " +
                time[0] + " hours " +
                time[1] + " minutes " +
                time[2] + " seconds.");


    }

    private static Period getPeriod(LocalDateTime dob, LocalDateTime now) {
        return Period.between(dob.toLocalDate(), now.toLocalDate());
    }

    private static long[] getTime(LocalDateTime dob, LocalDateTime now) {
        LocalDateTime today = LocalDateTime.of(now.getYear(),
                now.getMonthValue(), now.getDayOfMonth(), dob.getHour(), dob.getMinute(), dob.getSecond());
        Duration duration = Duration.between(today, now);

        long seconds = duration.getSeconds();

        long hours = seconds / SECONDS_PER_HOUR;
        long minutes = ((seconds % SECONDS_PER_HOUR) / SECONDS_PER_MINUTE);
        long secs = (seconds % SECONDS_PER_MINUTE);

        return new long[]{hours, minutes, secs};
    }
}

আমি যে আউটপুট পাচ্ছি তা হ'ল 29 years 8 months 24 days 12 hours 0 minutes 50 seconds। আমি এই ওয়েবসাইটটি (মান 12/16/1984 07:45:55এবং সহ 09/09/2014 19:46:45) থেকে আমার ফলাফল পরীক্ষা করেছি । নিম্নলিখিত স্ক্রিনশট আউটপুট দেখায়:

যুগের রূপান্তরকারী

আমি নিশ্চিত যে মাসের মানের পরে ক্ষেত্রগুলি আমার কোড থেকে ভুল হয়ে আসছে am কোন পরামর্শ খুব সহায়ক হবে।

হালনাগাদ

আমি অন্য ওয়েবসাইট থেকে আমার ফলাফলটি পরীক্ষা করে দেখেছি যে ফলাফলটি ভিন্ন। এটি এখানে: দুটি তারিখের মধ্যে সময়কাল গণনা করুন (ফলাফল: 29 বছর, 8 মাস, 24 দিন, 12 ঘন্টা, 0 মিনিট এবং 50 সেকেন্ড)।

হালনাগাদ

যেহেতু আমি দুটি ভিন্ন সাইট থেকে দুটি পৃথক ফলাফল পেয়েছি, তাই আমি ভাবছি যে আমার গণনার অ্যালগোরিদম বৈধ কিনা। আমি যদি নিম্নলিখিত দুটি LocalDateTimeবস্তু ব্যবহার করি :

LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 10, 6, 40, 45);
LocalDateTime fromDateTime = LocalDateTime.of(1984, 12, 16, 7, 45, 55);

তারপরে আউটপুট আসছে: 29 years 8 months 25 days -1 hours -5 minutes -10 seconds.

এই লিঙ্ক থেকে এটি হওয়া উচিত 29 years 8 months 24 days 22 hours, 54 minutes and 50 seconds। সুতরাং অ্যালগরিদমকেও নেতিবাচক সংখ্যাগুলি পরিচালনা করতে হবে।

প্রশ্নটি নোট করুন কোন সাইটটি আমাকে কী ফলাফল দিয়েছে সে সম্পর্কে নয়, আমার সঠিক অ্যালগরিদমটি জানতে হবে এবং সঠিক ফলাফল হওয়া দরকার।


শুধু অনুমান, কিন্তু Period.between()কিছু বৃত্তাকার প্রয়োগ করতে পারে?
থমাস

3
আমি কেবল আরও একবার কোডটির দিকে চেয়েছি এবং মনে হচ্ছে ওয়েবসাইটটি ভুল (নিজেকে গণনা করার চেষ্টা করুন)। আপনি যদি তারিখটি বাদ দেন, অর্থাত্ বছর, মাস এবং দিনের পার্থক্যগুলি, আপনি শুরুর সময় 7:45:55এবং শেষ সময় 19:46:45(বা 7:46:45প্রধানমন্ত্রী) পাবেন। সুতরাং এই দুটি সময়ের মধ্যে পার্থক্য হল 12 ঘন্টা, 0 মিনিট এবং 50 সেকেন্ড এবং কখনই 23 ঘন্টা, 34 মিনিট এবং 12 সেকেন্ড। সুতরাং আপনার গণনাটি বাস্তবে সঠিক বলে মনে হচ্ছে, কমপক্ষে সময় অংশে।
থমাস

1
সেই ওয়েবসাইটে আকর্ষণীয় ঘটনা: প্রারম্ভিক তারিখের 10 বছর এবং ঘন্টার মধ্যে পার্থক্য 23 থেকে 8 পরিবর্তিত হয় - অবশ্যই বাগের চিহ্ন।
টমাস

8
মনে রাখবেন যেহেতু LocalDateTimeকোনও টাইম অঞ্চল নেই, তাই কোনও অনন্য উত্তর নাও থাকতে পারে। এমনকি যদি আপনি ধরে নেন যে শুরু এবং শেষ সময় অঞ্চলগুলি একই রকম হয় তবে নির্দিষ্ট জোনগুলিতে 2014-09-09 যেমন দিবালোক সংরক্ষণের সময় বা গ্রীষ্মকালীন সময় এবং অন্যগুলিতে তা না হয় dates এটি এক ঘন্টার মধ্যে জিনিসগুলি ফেলে দিতে পারে। সুতরাং এটির সমাধান না হলে পার্থক্যটিকে দ্বিতীয়টিতে গণনা করা অর্থহীন।
স্টুয়ার্ট

2
আপনি কি বুঝতে পেরেছেন যে LocalDateTimeশ্রেণিটি উদ্দেশ্যমূলকভাবে সময় অঞ্চল বা অফসেট-ইউটিসি-র কোনও ধারণার অভাব অনুসারে অবাস্তব ফলাফল ব্যবহার করে? বাস্তবসম্মত মানগুলির জন্য, ZoneIdব্যবহারের মাধ্যমে একটি সময় অঞ্চল নির্ধারণ করুন ZonedDateTime
বাসিল বার্ক

উত্তর:


163

দুর্ভাগ্যক্রমে, এমন একটি পিরিয়ড ক্লাসও মনে হচ্ছে না যা সময় বিস্তৃত হয়, তাই আপনাকে নিজের থেকে গণনাগুলি করতে হতে পারে।

ভাগ্যক্রমে, তারিখ এবং সময় শ্রেণীর অনেকগুলি ইউটিলিটি পদ্ধতি রয়েছে যা কিছুটা ডিগ্রীতে সহজ করে দেয়। অগত্যা দ্রুততম না হলেও পার্থক্য গণনা করার একটি উপায় এখানে:

LocalDateTime fromDateTime = LocalDateTime.of(1984, 12, 16, 7, 45, 55);
LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 10, 6, 40, 45);

LocalDateTime tempDateTime = LocalDateTime.from( fromDateTime );

long years = tempDateTime.until( toDateTime, ChronoUnit.YEARS );
tempDateTime = tempDateTime.plusYears( years );

long months = tempDateTime.until( toDateTime, ChronoUnit.MONTHS );
tempDateTime = tempDateTime.plusMonths( months );

long days = tempDateTime.until( toDateTime, ChronoUnit.DAYS );
tempDateTime = tempDateTime.plusDays( days );


long hours = tempDateTime.until( toDateTime, ChronoUnit.HOURS );
tempDateTime = tempDateTime.plusHours( hours );

long minutes = tempDateTime.until( toDateTime, ChronoUnit.MINUTES );
tempDateTime = tempDateTime.plusMinutes( minutes );

long seconds = tempDateTime.until( toDateTime, ChronoUnit.SECONDS );

System.out.println( years + " years " + 
        months + " months " + 
        days + " days " +
        hours + " hours " +
        minutes + " minutes " +
        seconds + " seconds.");

//prints: 29 years 8 months 24 days 22 hours 54 minutes 50 seconds.

মূল ধারণাটি হ'ল: একটি অস্থায়ী শুরুর তারিখ তৈরি করুন এবং পুরো বছর শেষের দিকে পান। তারপরে সেই তারিখটিকে বছরের সংখ্যা অনুসারে সামঞ্জস্য করুন যাতে শুরুর তারিখ শেষে থেকে এক বছর কম হয়। অবতরণ ক্রমে প্রতিটি সময় ইউনিটের জন্য এটি পুনরাবৃত্তি করুন।

পরিশেষে একটি দাবি অস্বীকার : আমি আলাদা আলাদা সময় অঞ্চল বিবেচনা করি নি (উভয় তারিখ একই টাইমজোনের হওয়া উচিত) এবং কোনও ক্যালেন্ডারে কীভাবে দিবালোকের সময় বাঁচানোর সময় বা অন্যান্য পরিবর্তনগুলি পরীক্ষা করে / পরীক্ষা করে দেখিনি (সামোয়াতে টাইমজোন পরিবর্তনের মতো) এই গণনা প্রভাবিত। তাই যত্ন সহকারে ব্যবহার করুন।


1
আপনার একই বুনিয়াদী ধারণা আছে, তাই আমার আপভোট, তবে দয়া করে একই ইনপুটটি ব্যবহার করার চেষ্টা করুন অন্যথায় ভিন্ন ফলাফল বিভ্রান্তিকর।
মেনো হচসচাইল্ড

@MenoHochschild এটা হল একই ইনপুট শুধু আপডেট যেখানে ওপি নেতিবাচক বার সঙ্গে বিষয় আছে থেকে নেওয়া। ;)
টমাস

1
ভাল অ্যালগরিদম, তবে ভুল টাইপ (থমাস অস্বীকৃতি দেখুন)। আপনার গণনা করার আগে, আপনার স্থানীয় স্থানীয় তারিখের পরিবর্তনশীলগুলিকে ডিফল্ট সময় অঞ্চল ব্যবহার করে জোডনেডটাইম টাইমে রূপান্তর করা উচিত (উদাহরণস্বরূপ (অথবা যে কোনও সময় অঞ্চল আপনার প্রয়োজন): জোনেডেটটাইম থেকে জোনেডেটটাইম = fromDateTime.atZone (অঞ্চলআইড.সিস্টেমডিফাল্ট ());
ত্রিস্তান

2
@ থমাস আপনার উদাহরণটি জাভা 8 ব্যবহার করছে - এবং প্রশ্নটি জাভা -8 হিসাবে ট্যাগ করা আছে। আসলে আপনার উদাহরণটি এমনকি ব্যবহার ChronoUnitকরছে :) তবে কাজটি "হাত দিয়ে" করছেন।
ইউজিন বেরেসভস্কি

3
@ ইউজেনবিরেসভস্কি ওহ হ্যাঁ, আপনি ঠিক বলেছেন সম্পূর্ণরূপে এটি মিস হয়েছে;) - এগুলি ছাড়াও, আপনাকে এখনও অন্তর থেকে বৃহত্তর ইউনিটগুলি বিয়োগ করতে long minutes = ChronoUnit.MINUTES.between(fromDate, toDate);হবে কারণ উদাহরণস্বরূপ কমপক্ষে 1 ঘন্টার ব্যবধানে 59 এর চেয়ে বেশি সংখ্যক সংখ্যা ফিরে আসবে - এবং এটি ওপি চায় না। এটি অ্যাকাউন্টে নিলে আপনি কেবলমাত্র 6 টি কল করতে ChronoUnit#between()এবং করতে সক্ষম হবেন না ।
টমাস

502

আমি এর সেরা উপায়টি খুঁজে পেয়েছি ক্রোনোইনিতের সাথে।

long minutes = ChronoUnit.MINUTES.between(fromDate, toDate);
long hours = ChronoUnit.HOURS.between(fromDate, toDate);

অতিরিক্ত ডকুমেন্টেশন এখানে: https://docs.oracle.com/javase/tutorial/datetime/iso/period.html


8
আমি বাস্তব উন্নতি দেখতে পাচ্ছি না। স্বীকৃত থমাসের উত্তরের সাথে তুলনা করে আপনি কেবল এটির tempDateTime.until( toDateTime, ChronoUnit.YEARS)সাথে প্রতিস্থাপন করেন ChronoUnit.YEARS.between(fromDate, toDate)। তবে tempDateTime.plusYears( years )ইত্যাদির মতো গুরুত্বপূর্ণ অতিরিক্ত লাইনগুলি আপনার উত্তরে সম্পূর্ণ অনুপস্থিত তাই এটি ওপিকে সহায়তা করে না। সম্পূর্ণ অ্যালগরিদম ব্যাপার!
মেনো হচসচাইল্ড

9
আমি এটি আরও ভাল পছন্দ করি যেহেতু এটি আরও সংক্ষিপ্ত এবং আরও পাঠযোগ্য read দুটি তারিখের মধ্যে পার্থক্য খুঁজে পাওয়ার সেরা উপায় এটি।
সোমাইয়া কুম্বের

7
@ সোমাইয়া কুম্বের আপনি কোনটিই সমালোচনামূলক পয়েন্টটি পুরোপুরি মিস করবেন না। ওপি কেবল একটি ইউনিটে নয় বরং একাধিক ইউনিটের সময়কাল চায় এবং তাই এই উত্তরটি মোটেই আসল উত্তর নয়। ওপি'র উদ্বেগের সমাধান করা যায় না। প্রশ্নটি আবার পড়তে দয়া করে দয়া করুন। (অনেকগুলি আপোভেটর মনে হয় প্রশ্নটি ভুল বুঝেছেন)।
মেনো হচসচাইল্ড

125
@ মেনো হচসচাইল্ড, আমি মনে করি আপনি আসলে সেই সমালোচক বিন্দুটি অনুপস্থিত। এক বছর আগে ওপি তাদের উত্তর পেয়েছিল। এই প্রশ্নটি যে 36 হাজার লোক দেখছেন তারা ওপি-র নির্দিষ্ট প্রশ্নের বিষয়ে চিন্তা করে না। গুগলের মাধ্যমে তারা এখানে নেতৃত্ব দিয়েছিল এবং আমার উত্তর তাদের যা চেয়েছিল তা সরবরাহ করেছিল - দুটি তারিখের মধ্যে পার্থক্য পাওয়ার জন্য একটি পরিষ্কার এবং সহজ সমাধান।
সাতম

10
আমার দুটি তারিখের সময়ের মধ্যে সেকেন্ডের পার্থক্য প্রয়োজন এবং নিজের সমাধানটি প্রয়োগ করতে শুরু করি। খুব শীঘ্রই এটি জটিল বলে মনে হচ্ছে এবং আমি গুগল গ্রহণ করেছি। সাতনাম উত্তর ওপি প্রশ্নের উত্তর নাও দিতে পারে তবে অবশ্যই আমাকে অনেক সাহায্য করেছে এবং আমি আমার মতো আরও অনেককে বাজি ধরেছি।
জুলিয়ান

43

এখানে 'এইচএচ: মিমি: এসএস' ফর্ম্যাটটি পেতে সময়কাল এবং টাইমউনিত ব্যবহার করে একটি একক উদাহরণ।

Duration dur = Duration.between(localDateTimeIni, localDateTimeEnd);
long millis = dur.toMillis();

String.format("%02d:%02d:%02d", 
        TimeUnit.MILLISECONDS.toHours(millis),
        TimeUnit.MILLISECONDS.toMinutes(millis) - 
        TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)),
        TimeUnit.MILLISECONDS.toSeconds(millis) - 
        TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)));

2
এটা আসলে ভালো এটা করতে সম্ভব: String.format("%02d:%02d:%02d",dur.toHoursPart(), dur.toMinutesPart(), dur.toSecondsPart());। অংশের পদ্ধতিগুলি আপনাকে স্ট্রিং তৈরির জন্য সঠিক সংখ্যা দেয়। আমি মনে করি এটি আরও পাঠযোগ্য।
দান্তি

আমার পূর্ববর্তী মন্তব্যে পার্শ্ব দ্রষ্টব্য: পার্টের পদ্ধতিগুলি কেবল জেডিকে 9 এবং তার থেকে বেশি উপলব্ধ।
দান্তি

40

এটি সহজ হতে হবে!

Duration.between(startLocalDateTime, endLocalDateTime).toMillis();

1
আমি বিশ্বাস করি এটি জাভা ৮ থেকে শুরু করে শব্দার্থগতভাবে সঠিক সমাধান And
ভ্রাকফল

9

টি এল; ডিআর

Duration duration = Duration.between(start, end);
duration = duration.minusDays(duration.toDaysPart()); // essentially "duration (mod 1 day)"
Period period = Period.between(start.toLocalDate(), end.toLocalDate());

এবং তারপর পদ্ধতি ব্যবহার period.getYears(), period.getMonths(), period.getDays(), duration.toHoursPart(), duration.toMinutesPart(), duration.toSecondsPart()


প্রসারিত উত্তর

আমি মূল প্রশ্নের উত্তর দেব, অর্থাত্ কিভাবে LocalDateTimesবছর, মাস, দিন, ঘন্টা এবং মিনিটের মধ্যে দুটি সময়ের মধ্যে পার্থক্য পাওয়া যায় , যেমন বিভিন্ন ইউনিটের সমস্ত মানগুলির "যোগফল" (নীচের নোট দেখুন) মোট সমান সাময়িক পার্থক্য এবং এর মতো যে প্রতিটি ইউনিটের মান পরবর্তী বড় ইউনিটের চেয়ে ছোট — যেমন minutes < 60, hours < 24ইত্যাদি।

দুটি দেওয়া LocalDateTimes startএবং end, যেমন

LocalDateTime start = LocalDateTime.of(2019, 11, 29, 17, 15);
LocalDateTime end = LocalDateTime.of(2020, 11, 30, 18, 44);

আমরা দু'জনের মধ্যে যথাসম্ভব Durationটাইমস্প্যানটি ব্যবহার করে একটি বড় বাঘ ব্যবহার করে প্রতিনিধিত্ব করতে পারি Duration.between(start, end)। তবে আমরা যে বৃহত্তম ইউনিটটি বের করতে পারি তা Durationহ'ল দিনগুলি (24 ঘন্টা সমতুল্য একক হিসাবে) - ব্যাখ্যাটির জন্য নীচের নোটটি দেখুন। বৃহত্তর ইউনিট (মাস, বছর) ব্যবহার করার জন্য আমরা এর Durationজুড়ি ( Period, Duration) এর সাথে এটি উপস্থাপন করতে পারি , যেখানে কয়েক Periodদিনের যথার্থতা পর্যন্ত পার্থক্যগুলি পরিমাপ করা হয় এবং অবশিষ্টগুলি Durationপ্রতিনিধিত্ব করে:

Duration duration = Duration.between(start, end);
duration = duration.minusDays(duration.toDaysPart()); // essentially "duration (mod 1 day)"
Period period = Period.between(start.toLocalDate(), end.toLocalDate());

এখন আমরা স্বতন্ত্র ইউনিটগুলির উপর নির্ধারণ Periodএবং Durationনিষ্কাশন করার জন্য কেবল পদ্ধতিগুলি ব্যবহার করতে পারি :

System.out.printf("%d years, %d months, %d days, %d hours, %d minutes, %d seconds",
        period.getYears(), period.getMonths(), period.getDays(), duration.toHoursPart(),
        duration.toMinutesPart(), duration.toSecondsPart());
1 years, 0 months, 1 days, 1 hours, 29 minutes, 0 seconds

বা, ডিফল্ট ফর্ম্যাট ব্যবহার করে:

System.out.println(period + " + " + duration);
P1Y1D + PT1H29M

বছর, মাস এবং দিনগুলিতে নোট

নোট করুন যে, java.timeধারণার মধ্যে, "মাস" বা "বছর" এর মতো "ইউনিটগুলি একটি স্থির, নিরঙ্কুশ অস্থায়ী মান উপস্থাপন করে না — তারা তারিখ- এবং ক্যালেন্ডার-নির্ভর, যেমন নীচের উদাহরণটি চিত্রিত করে:

LocalDateTime
        start1 = LocalDateTime.of(2020, 1, 1, 0, 0),
        end1 = LocalDateTime.of(2021, 1, 1, 0, 0),
        start2 = LocalDateTime.of(2021, 1, 1, 0, 0),
        end2 = LocalDateTime.of(2022, 1, 1, 0, 0);
System.out.println(Period.between(start1.toLocalDate(), end1.toLocalDate()));
System.out.println(Duration.between(start1, end1).toDays());
System.out.println(Period.between(start2.toLocalDate(), end2.toLocalDate()));
System.out.println(Duration.between(start2, end2).toDays());
P1Y
366
P1Y
365

5

তাপস বোস কোড এবং থমাস কোডের জন্য কিছু সমস্যা আছে। যদি সময়ের পার্থক্য negativeণাত্মক হয় তবে অ্যারেটি নেতিবাচক মানগুলি পায়। উদাহরণস্বরূপ যদি

LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 10, 6, 46, 45);
LocalDateTime fromDateTime = LocalDateTime.of(2014, 9, 9, 7, 46, 45);

এটি 0 বছর 0 মাস 1 দিন -1 ঘন্টা 0 মিনিট 0 সেকেন্ডে ফিরে আসে।

আমি মনে করি সঠিক ফলাফল: 0 বছর 0 মাস 0 দিন 23 ঘন্টা 0 মিনিট 0 সেকেন্ড।

আমি স্থানীয় তারিখ এবং লোকালটাইম দৃষ্টান্তগুলিতে লোকালডেটটাইম উদাহরণগুলি পৃথক করার প্রস্তাব দিই। এর পরে আমরা জাভা 8 পিরিয়ড এবং সময়কাল দৃষ্টান্তগুলি পেতে পারি। সময়কাল উদাহরণটি সময়ের সংখ্যার পরবর্তী সংশোধন সহ দিনের সংখ্যা এবং সারা দিনের সময় মান (<24 ঘন্টা) দ্বারা পৃথক করা হয়। যখন দ্বিতীয় লোকালটাইম মান প্রথম লোকালটাইম মানের আগে হয়, তখন এক দিনের জন্য পিরিয়ড হ্রাস করা প্রয়োজন।

লোকালডেটটাইম পার্থক্য গণনা করার জন্য এখানে আমার উপায়:

private void getChronoUnitForSecondAfterFirst(LocalDateTime firstLocalDateTime, LocalDateTime secondLocalDateTime, long[] chronoUnits) {
    /*Separate LocaldateTime on LocalDate and LocalTime*/
    LocalDate firstLocalDate = firstLocalDateTime.toLocalDate();
    LocalTime firstLocalTime = firstLocalDateTime.toLocalTime();

    LocalDate secondLocalDate = secondLocalDateTime.toLocalDate();
    LocalTime secondLocalTime = secondLocalDateTime.toLocalTime();

    /*Calculate the time difference*/
    Duration duration = Duration.between(firstLocalDateTime, secondLocalDateTime);
    long durationDays = duration.toDays();
    Duration throughoutTheDayDuration = duration.minusDays(durationDays);
    Logger.getLogger(PeriodDuration.class.getName()).log(Level.INFO,
            "Duration is: " + duration + " this is " + durationDays
            + " days and " + throughoutTheDayDuration + " time.");

    Period period = Period.between(firstLocalDate, secondLocalDate);

    /*Correct the date difference*/
    if (secondLocalTime.isBefore(firstLocalTime)) {
        period = period.minusDays(1);
        Logger.getLogger(PeriodDuration.class.getName()).log(Level.INFO,
                "minus 1 day");
    }

    Logger.getLogger(PeriodDuration.class.getName()).log(Level.INFO,
            "Period between " + firstLocalDateTime + " and "
            + secondLocalDateTime + " is: " + period + " and duration is: "
            + throughoutTheDayDuration
            + "\n-----------------------------------------------------------------");

    /*Calculate chrono unit values and  write it in array*/
    chronoUnits[0] = period.getYears();
    chronoUnits[1] = period.getMonths();
    chronoUnits[2] = period.getDays();
    chronoUnits[3] = throughoutTheDayDuration.toHours();
    chronoUnits[4] = throughoutTheDayDuration.toMinutes() % 60;
    chronoUnits[5] = throughoutTheDayDuration.getSeconds() % 60;
}

উপরোক্ত পদ্ধতিটি যে কোনও স্থানীয় তারিখ এবং সময় মানগুলির পার্থক্য গণনা করতে ব্যবহার করা যেতে পারে, উদাহরণস্বরূপ:

public long[] getChronoUnits(String firstLocalDateTimeString, String secondLocalDateTimeString) {
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    LocalDateTime firstLocalDateTime = LocalDateTime.parse(firstLocalDateTimeString, formatter);
    LocalDateTime secondLocalDateTime = LocalDateTime.parse(secondLocalDateTimeString, formatter);

    long[] chronoUnits = new long[6];
    if (secondLocalDateTime.isAfter(firstLocalDateTime)) {
        getChronoUnitForSecondAfterFirst(firstLocalDateTime, secondLocalDateTime, chronoUnits);
    } else {
        getChronoUnitForSecondAfterFirst(secondLocalDateTime, firstLocalDateTime, chronoUnits);
    }
    return chronoUnits;
}

উপরের পদ্ধতির জন্য ইউনিট পরীক্ষা লিখতে সুবিধাজনক (উভয়ই পিরিওডডিউরেশন শ্রেণির সদস্য)। কোডটি এখানে:

@RunWith(Parameterized.class)
public class PeriodDurationTest {

private final String firstLocalDateTimeString;
private final String secondLocalDateTimeString;
private final long[] chronoUnits;

public PeriodDurationTest(String firstLocalDateTimeString, String secondLocalDateTimeString, long[] chronoUnits) {
    this.firstLocalDateTimeString = firstLocalDateTimeString;
    this.secondLocalDateTimeString = secondLocalDateTimeString;
    this.chronoUnits = chronoUnits;
}

@Parameters
public static Collection<Object[]> periodValues() {
    long[] chronoUnits0 = {0, 0, 0, 0, 0, 0};
    long[] chronoUnits1 = {0, 0, 0, 1, 0, 0};
    long[] chronoUnits2 = {0, 0, 0, 23, 0, 0};
    long[] chronoUnits3 = {0, 0, 0, 1, 0, 0};
    long[] chronoUnits4 = {0, 0, 0, 23, 0, 0};
    long[] chronoUnits5 = {0, 0, 1, 23, 0, 0};
    long[] chronoUnits6 = {29, 8, 24, 12, 0, 50};
    long[] chronoUnits7 = {29, 8, 24, 12, 0, 50};
    return Arrays.asList(new Object[][]{
        {"2015-09-09 21:46:44", "2015-09-09 21:46:44", chronoUnits0},
        {"2015-09-09 21:46:44", "2015-09-09 22:46:44", chronoUnits1},
        {"2015-09-09 21:46:44", "2015-09-10 20:46:44", chronoUnits2},
        {"2015-09-09 21:46:44", "2015-09-09 20:46:44", chronoUnits3},
        {"2015-09-10 20:46:44", "2015-09-09 21:46:44", chronoUnits4},
        {"2015-09-11 20:46:44", "2015-09-09 21:46:44", chronoUnits5},
        {"1984-12-16 07:45:55", "2014-09-09 19:46:45", chronoUnits6},
        {"2014-09-09 19:46:45", "1984-12-16 07:45:55", chronoUnits6}
    });
}

@Test
public void testGetChronoUnits() {
    PeriodDuration instance = new PeriodDuration();
    long[] expResult = this.chronoUnits;
    long[] result = instance.getChronoUnits(this.firstLocalDateTimeString, this.secondLocalDateTimeString);
    assertArrayEquals(expResult, result);
}

}

প্রথম লোকালডিটটাইমের মান আগে এবং কোনও লোকালটাইম মানের জন্য কিনা তা সমস্ত পরীক্ষাগুলি সফল।


উপরে আপনার ইনপুটটি ব্যবহার করে থমাস কোড মিশ্র লক্ষণ তৈরি করে তা আমি আপনার বিবৃতি পুনরুত্পাদন করতে পারি না। আমার আউটপুট: "0 বছর 0 মাস 0 দিন 23 ঘন্টা 0 মিনিট 0 সেকেন্ড"। এবং আমি এখনই পরীক্ষা করেছি।
মেনো হচসচাইল্ড

মন্তব্য করার জন্য আপনাকে ধন্যবাদ. আমি থমাস কোডটি পুঙ্খানুপুঙ্খভাবে পরীক্ষা করেছি, প্রকৃতপক্ষে, এটি সঠিকভাবে কাজ করছে! ক্রোনো ইউনিটগুলি সংশোধন না করার পদ্ধতি অবধি ম্যাজিকটি লোকালডেটটাইম দ্বারা করা হয়। থমাস কোডে নেতিবাচক মানগুলি উপস্থিত হয় যদি প্রথম ডেটটাইম দ্বিতীয়টির চেয়ে পরে হয়। তবে এটি সহজে সংশোধন করা যায়, উদাহরণস্বরূপ, যেমন আমি উপরের কোডটিতে করেছিলাম। আবার ধন্যবাদ.
জেনাদে কোলোমেটস

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

5

আর এ @Thomas সংস্করণ খাঁজকাটা পরিবর্তে মান hardcoding একটি তালিকা কাঙ্ক্ষিত ইউনিট লাগে। এই বাস্তবায়ন (যা সহজেই জাভাতে পোর্ট করা যায় - আমি ফাংশন ঘোষণাটি স্পষ্ট করে দিয়েছিলাম) থমাসের পদ্ধতির আরও পুনঃব্যবহারযোগ্য করে তোলে।

def fromDateTime = LocalDateTime.of(1968, 6, 14, 0, 13, 0)
def toDateTime = LocalDateTime.now()
def listOfUnits = [
    ChronoUnit.YEARS, ChronoUnit.MONTHS, ChronoUnit.DAYS,
    ChronoUnit.HOURS, ChronoUnit.MINUTES, ChronoUnit.SECONDS,
    ChronoUnit.MILLIS]

println calcDurationInTextualForm(listOfUnits, fromDateTime, toDateTime)    

String calcDurationInTextualForm(List<ChronoUnit> listOfUnits, LocalDateTime ts, LocalDateTime to)
{
    def result = []

    listOfUnits.each { chronoUnit ->
        long amount = ts.until(to, chronoUnit)
        ts = ts.plus(amount, chronoUnit)

        if (amount) {
            result << "$amount ${chronoUnit.toString()}"
        }
    }

    result.join(', ')
}

এই লেখার সময়, উপরের কোডটি ফেরত দেয় 47 Years, 8 Months, 9 Days, 22 Hours, 52 Minutes, 7 Seconds, 140 Millis। এবং, জেনাড্ডি কোলোমেটস ইনপুটটির জন্য কোডটি ফেরত দেয় 23 Hours

আপনি যখন ইউনিটগুলির একটি তালিকা সরবরাহ করেন এটি অবশ্যই ইউনিটের আকার অনুসারে বাছাই করতে হবে (বৃহত্তম বৃহত্তম):

def listOfUnits = [ChronoUnit.WEEKS, ChronoUnit.DAYS, ChronoUnit.HOURS]
// returns 2495 Weeks, 3 Days, 8 Hours

4

আপনার প্রশ্নের একটি খুব সহজ উত্তর এখানে। এটা কাজ করে।

import java.time.*;
import java.util.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;

public class MyClass {
public static void main(String args[]) {
    DateTimeFormatter T = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm");
    Scanner h = new Scanner(System.in);

    System.out.print("Enter date of birth[dd/mm/yyyy hh:mm]: ");
    String b = h.nextLine();

    LocalDateTime bd = LocalDateTime.parse(b,T);
    LocalDateTime cd = LocalDateTime.now();

    long minutes = ChronoUnit.MINUTES.between(bd, cd);
    long hours = ChronoUnit.HOURS.between(bd, cd);

    System.out.print("Age is: "+hours+ " hours, or " +minutes+ " minutes old");
}
}

1
আমার উল্লেখ করা উচিত এটি সঠিক নয়। এটি দিয়ে চেষ্টা করুন। এটি বলে 1 মিনিটের পার্থক্য। লোকালডেটটাইম বিডি = লোকালডেটটাইম.ওফ (2019, 11, 26, 15, 03, 55); লোকালডেটটাইম সিডি = লোকালডেটটাইম.ওফ (2019, 11, 26, 15, 04, 45);
মার্ক Amabile

আমি গত রাতে একটি সময় প্রবেশ করে পেয়েছি Age is: 0 years,0 months, 1 days, -10 hours, -48 minutes old। আমি মনে করি না এটিই যা চেয়েছিল।
ওলে ভিভি 11

@ OleV.V। এই সমস্যাটি স্থির করে
স্যাভডবিউ

1

Joda-টাইম

যেহেতু বেশিরভাগ উত্তরের জন্য এপিআই 26 সমর্থন প্রয়োজন এবং আমার ন্যূনতম এপিআই 23, তাই আমি নীচের কোড দ্বারা এটি সমাধান করেছি:

import org.joda.time.Days

LocalDate startDate = Something
LocalDate endDate = Something
// The difference would be exclusive of both dates, 
// so in most of use cases we may need to increment it by 1
Days.daysBetween(startDate, endDate).days

1
Joda-টাইম প্রকল্প, রক্ষণাবেক্ষণ মোডে রয়েছে তার স্রষ্টা স্টিফেন Colebourne তৈরি করার গিয়ে java.time JSR 310. সংজ্ঞায়িত ক্লাস সর্বাধিক java.time কার্যকারিতা জাভা 6 ও 7 ব্যাক বৈশিষ্ট্যসমূহ নিয়ে আসা হয় ThreeTen- ব্যাকপোর্ট প্রকল্প থ্রিটেনএবিপি প্রকল্পে প্রারম্ভিক অ্যান্ড্রয়েডের জন্য আরও অভিযোজিত ।
বেসিল Bourque

1

পাঁচ বছরেরও বেশি সময় পরে আমি আমার প্রশ্নের উত্তর দিই। আমি মনে করি যে একটি নেতিবাচক সময়কাল সহ সমস্যাটি একটি সাধারণ সংশোধন দ্বারা সমাধান করা যেতে পারে:

LocalDateTime fromDateTime = LocalDateTime.of(2014, 9, 9, 7, 46, 45);
LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 10, 6, 46, 45);

Period period = Period.between(fromDateTime.toLocalDate(), toDateTime.toLocalDate());
Duration duration = Duration.between(fromDateTime.toLocalTime(), toDateTime.toLocalTime());

if (duration.isNegative()) {
    period = period.minusDays(1);
    duration = duration.plusDays(1);
}
long seconds = duration.getSeconds();
long hours = seconds / SECONDS_PER_HOUR;
long minutes = ((seconds % SECONDS_PER_HOUR) / SECONDS_PER_MINUTE);
long secs = (seconds % SECONDS_PER_MINUTE);
long time[] = {hours, minutes, secs};
System.out.println(period.getYears() + " years "
            + period.getMonths() + " months "
            + period.getDays() + " days "
            + time[0] + " hours "
            + time[1] + " minutes "
            + time[2] + " seconds.");

দ্রষ্টব্য: সাইট https://www.epochconverter.com/date-differences এখন সঠিকভাবে সময়ের পার্থক্য গণনা করে।

আপনার আলোচনা এবং পরামর্শের জন্য আপনাকে ধন্যবাদ।


উত্তর করার জন্য ধন্যবাদ. ঘন্টা এবং ছোট জন্য আপনি থেকে উপকৃত হতে পারেন toHours, toMinutesএবং toSecondsপদ্ধতি Duration। জাভা 9 এমনকি আরো অনেক কিছু থেকে যেহেতু toMinutesPart()এবং toSecondsPart()। এবং ঘন্টাগুলি, মিনিট এবং সেকেন্ডগুলিকে কেবল আবার বাইরে নিয়ে যাওয়ার জন্য অ্যারেতে গুটিয়ে ফেলার বিষয়টি আমি দেখতে পাই না। সাধারণত একটি ভাল উত্তর, যদিও।
ওলে ভিভি

পাঁচ বছরেরও বেশি সময় পরে আমি আমার প্রশ্নের উত্তর দিই। প্রশ্নটি একটি অ্যাকাউন্ট থেকে আলাদা নাম, শিরোনাম এবং অবস্থান সহ পোস্ট করা হয়েছিল, এর সাথে খুব একটা সাদৃশ্য বলে মনে হচ্ছে না? এটির কোনও গুরুত্ব নেই কেবল, অবাক করেই।
ওলে ভিভি

"পাঁচ বছরেরও বেশি সময় পরে আমি আমার প্রশ্নের উত্তর দিয়েছি" আমি মনে করি আমি ওপি ছিলাম :)
তাপস বোস
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.