सवाल जावा में दो तिथियों के बीच सप्ताहांत की संख्या की गणना करें


क्या कोई मुझे कुछ जावा स्निपेट पर इंगित कर सकता है जिसमें मैं दो तिथियों के बीच दिन (शनि और सूर्य को छोड़कर) व्यवसाय प्राप्त कर सकता हूं।


44
2018-01-05 01:14


मूल


joda-time.sourceforge.net - marcog


जवाब:


public static int getWorkingDaysBetweenTwoDates(Date startDate, Date endDate) {
    Calendar startCal = Calendar.getInstance();
    startCal.setTime(startDate);        

    Calendar endCal = Calendar.getInstance();
    endCal.setTime(endDate);

    int workDays = 0;

    //Return 0 if start and end are the same
    if (startCal.getTimeInMillis() == endCal.getTimeInMillis()) {
        return 0;
    }

    if (startCal.getTimeInMillis() > endCal.getTimeInMillis()) {
        startCal.setTime(endDate);
        endCal.setTime(startDate);
    }

    do {
       //excluding start date
        startCal.add(Calendar.DAY_OF_MONTH, 1);
        if (startCal.get(Calendar.DAY_OF_WEEK) != Calendar.SATURDAY && startCal.get(Calendar.DAY_OF_WEEK) != Calendar.SUNDAY) {
            ++workDays;
        }
    } while (startCal.getTimeInMillis() < endCal.getTimeInMillis()); //excluding end date

    return workDays;
}

प्रारंभ तिथि और समाप्ति तिथि अनन्य हैं, केवल दिए गए दिनों के बीच   तारीखों की गणना की जाएगी। प्रारंभ तिथि और समाप्ति तिथि शामिल नहीं की जाएगी।


39
2018-01-05 01:20



अगर प्रारंभ दिनांक अंतराल पर या उसके बाद है तो कुछ अजीब जवाब प्राप्त करें। यदि स्टार्टडेट 1 9 70-01-01 21:27:00 है और एंडडेट 1 9 70-01-01 18:00:00 है, तो फ़ंक्शन उसी दिनांक के बीच 0 दिनों के बजाय 1 लौटाता है। अगर स्टार्टडेट 2011-01-05 21:27:00 है और एंडडेट 2011-01-04 00:00:00 फ़ंक्शन -1 या 1 के बजाय 2 लौटाता है (यदि पूर्ण मान अपेक्षित हैं)। - Joseph Gordon
उपर्युक्त कोड स्निपेट समय के बिना दो तिथियों के बीच कार्य दिवसों की गणना के लिए है। - Piyush Mattoo
यह काम करता है, लेकिन निष्पादन समय दिनों की संख्या पर निर्भर करता है: - / - ymajoros
अगर स्थिति के बाद startdate जगह startCal.add (कैलेंडर.DAY_OF_MONTH, 1) को शामिल करने के लिए। - Harish
लूप के बिना 5-लाइनर: stackoverflow.com/a/44942039/480894 - Roland


उपाय लूप के बिना:

static long days(Date start, Date end){
    //Ignore argument check

    Calendar c1 = Calendar.getInstance();
    c1.setTime(start);
    int w1 = c1.get(Calendar.DAY_OF_WEEK);
    c1.add(Calendar.DAY_OF_WEEK, -w1);

    Calendar c2 = Calendar.getInstance();
    c2.setTime(end);
    int w2 = c2.get(Calendar.DAY_OF_WEEK);
    c2.add(Calendar.DAY_OF_WEEK, -w2);

    //end Saturday to start Saturday 
    long days = (c2.getTimeInMillis()-c1.getTimeInMillis())/(1000*60*60*24);
    long daysWithoutWeekendDays = days-(days*2/7);

    // Adjust days to add on (w2) and days to subtract (w1) so that Saturday
    // and Sunday are not included
    if (w1 == Calendar.SUNDAY && w2 != Calendar.SATURDAY) {
        w1 = Calendar.MONDAY;
    } else if (w1 == Calendar.SATURDAY && w2 != Calendar.SUNDAY) {
        w1 = Calendar.FRIDAY;
    } 

    if (w2 == Calendar.SUNDAY) {
        w2 = Calendar.MONDAY;
    } else if (w2 == Calendar.SATURDAY) {
        w2 = Calendar.FRIDAY;
    }

    return daysWithoutWeekendDays-w1+w2;
}

47
2018-01-05 03:17



वास्तव में आपके समाधान से प्रभावित। मैं एक ही चीज को पूरा करने की कोशिश कर रहा था लेकिन तारीख स्थानांतरण के बजाए सप्ताहांत पर शुरुआत और समाप्ति तिथियों को पकड़ने के लिए स्विच के साथ घायल हो गया। यह बहुत अधिक सुरुचिपूर्ण है। - Joseph Gordon
@ शेंगीआन: मुझे पता है कि यह थोड़ा देर हो चुकी है, लेकिन क्या आप कृपया अंतिम 2 लाइनों को समझा सकते हैं: long days = (c2.getTimeInMillis()-c1.getTimeInMillis())/(1000*60*60*24);  long daysWithoutSunday = days-(days*2/7); - Vrushank
पहली तारीख प्रारंभ तिथि और समाप्ति तिथि के बीच कुल दिनांक गणना है। दूसरी पंक्ति कुल तिथि गणना शून्य सप्ताहांत गिनती है। - iceberg
असंगत परिणाम: 2018-03-09 और 2018-03-10 (शुक्रवार और शनिवार) के बीच 0 दिन पैदा होते हैं। 2018-03-09 और 2018-03-11 (शुक्रवार और रविवार) के बीच 1 दिन पैदा होता है। - Roland
मेरा समाधान सही है: stackoverflow.com/a/44942039/480894 - Roland


मैंने शेंगुआन लू के समाधान का उपयोग किया, लेकिन मुझे उस मामले के लिए एक फिक्स करने की ज़रूरत थी जहां एक तिथि शनिवार को होती है और दूसरी रविवार को होती है - अन्यथा इसका जवाब एक दिन से दूर होता है:

static long days(Date start, Date end){
    //Ignore argument check

    Calendar c1 = GregorianCalendar.getInstance();
    c1.setTime(start);
    int w1 = c1.get(Calendar.DAY_OF_WEEK);
    c1.add(Calendar.DAY_OF_WEEK, -w1 + 1);

    Calendar c2 = GregorianCalendar.getInstance();
    c2.setTime(end);
    int w2 = c2.get(Calendar.DAY_OF_WEEK);
    c2.add(Calendar.DAY_OF_WEEK, -w2 + 1);

    //end Saturday to start Saturday 
    long days = (c2.getTimeInMillis()-c1.getTimeInMillis())/(1000*60*60*24);
    long daysWithoutSunday = days-(days*2/7);

    if (w1 == Calendar.SUNDAY) {
        w1 = Calendar.MONDAY;
    }
    if (w2 == Calendar.SUNDAY) {
        w2 = Calendar.MONDAY;
    }
    return daysWithoutSunday-w1+w2;
}

10
2017-11-03 23:13



आप शेंगुआन लू के समाधान को क्यों संपादित नहीं करते? - ymajoros


कोड की 5 लाइनों में लूप के बिना समाधान

बीच के दिनों को उसी तरह परिभाषित किया गया है ChronoUnit.DAYS.between(start, end) जिसका मतलब है कि वहाँ हैं 4 सोमवार और शुक्रवार के बीच के दिन। चूंकि हम केवल सप्ताह के दिनों में दिलचस्पी रखते हैं, इसलिए हमें सप्ताहांत घटा देना पड़ता है, इसलिए शुक्रवार से मंगलवार तक वहां होगा 2 सप्ताहांत (बस गणना करें endDay - startDay और घटाना 2 सप्ताहांत के लिए)। जोड़ना 1 परिणाम के लिए यदि आप एक चाहते हैं सम्मिलित नतीजा, यानी दिन के बीच नहीं।

मैं दो समाधान प्रस्तुत करता हूं।

पहला समाधान (5-लाइनर, छोटा और गुप्त):

import java.time.*;
import java.time.temporal.*;

public static long calcWeekDays1(final LocalDate start, final LocalDate end) {
    final DayOfWeek startW = start.getDayOfWeek();
    final DayOfWeek endW = end.getDayOfWeek();

    final long days = ChronoUnit.DAYS.between(start, end);
    final long daysWithoutWeekends = days - 2 * ((days + startW.getValue())/7);

    //adjust for starting and ending on a Sunday:
    return daysWithoutWeekends + (startW == DayOfWeek.SUNDAY ? 1 : 0) + (endW == DayOfWeek.SUNDAY ? 1 : 0);
}

दूसरा समाधान:

public static long calcWeekDays2(final LocalDate start, final LocalDate end) {
    final int startW = start.getDayOfWeek().getValue();
    final int endW = end.getDayOfWeek().getValue();

    final long days = ChronoUnit.DAYS.between(start, end);
    long result = days - 2*(days/7); //remove weekends

    if (days % 7 != 0) { //deal with the rest days
        if (startW == 7) {
            result -= 1;
        } else if (endW == 7) {  //they can't both be Sunday, otherwise rest would be zero
            result -= 1;
        } else if (endW < startW) { //another weekend is included
            result -= 2;
        }
    }

    return result;
}

8
2017-07-06 07:10



यदि दोनों प्रारंभ और समाप्ति तिथि शनिवार को या रविवार को दोनों होती है, तो यह गलत परिणाम देती है। - shanti
@shanti इसे अब तय किया जाना चाहिए। इसे इंगित करने के लिए फिर से धन्यवाद। - Roland


मेरे पास जावा आधारित समाधान नहीं है, लेकिन एक PHP है, उम्मीद है कि यह मदद करता है:

function getDate($days) {   
    for ($i = 0; $i < $days; $i ++) {                                      
        if (date('N' , strtotime('+' . ($i + 1) . ' days')) > 5) {  
            $days++;                                                        
        }                                                                   
    }                                                                       

    return date('l, F jS', strtotime('+' . $days . ' days', time()));
}

4
2018-01-05 01:20



आम तौर पर उम्मीद है कि आप प्रश्न के समान भाषा में पोस्ट करें, या ग्रोवी <-> जावा जैसे कुछ करीब। - Basil Bourque


java.time

आधुनिक तरीका जावा.टाइम कक्षाओं के साथ है।

LocalDate

LocalDate कक्षा समय-समय पर और समय क्षेत्र के बिना दिनांक-केवल मूल्य का प्रतिनिधित्व करती है।

LocalDate start = LocalDate.of( 2016 , 1 , 23 );
LocalDate stop = start.plusMonths( 1 );

DayOfWeek enum

DayOfWeek  enum प्रदान करता है एक एकाकी वस्तु सप्ताह के प्रत्येक अलग दिन के लिए उदाहरण।

DayOfWeek dow = start.getDayOfWeek();
if( dow.equals( DayOfWeek.SATURDAY ) || dow.equals( DayOfWeek.SUNDAY ) ) …

हम वांछित तिथियां एकत्र कर सकते हैं एक है List

int initialCapacity = Duration.between( start , stop ).toDays() ;
List<LocalDate> dates = new ArrayList<>( initialCapacity );
…
if( dow.equals( DayOfWeek.SATURDAY ) || dow.equals( DayOfWeek.SUNDAY ) ) {
    dates.add( date );
    …

एक EnumSet एक बेहद कुशल, तेज़ और कम स्मृति, कार्यान्वयन है Set। हम एक का उपयोग कर सकते हैं EnumSet के स्थान पर if ऊपर देखा गया बयान।

Set<DayOfWeek> weekend = EnumSet.of( DayOfWeek.SATURDAY , DayOfWeek.SUNDAY ) ;
…
if( weekend.contains( dayOfWeek ) ) …

सब एक साथ रखो।

LocalDate date = start ;
while( date.isBefore( stop ) ) {
    if( ! weekend.contains( date.getDayOfWeek() ) ) { // If not weekend, collect this LocalDate.
        dates.add( date ) ;
    }
    // Prepare for next loop.
    date = date.plusDays( 1 ); // Increment to next day.
}

nextWorkingDay TemporalAdjuster

एक और दृष्टिकोण का उपयोग करता है ThreeTen-अतिरिक्त java.time के साथ काम करने वाली कक्षाओं को जोड़ने की परियोजना।

Temporals कक्षा के अतिरिक्त कार्यान्वयन जोड़ता है TemporalAdjuster डेट-टाइम मानों में हेरफेर करने के लिए। हम चाहते हैं nextWorkingDay शनिवार और रविवार को छोड़ते समय तिथि बढ़ाने के लिए समायोजक।

LocalDate start = LocalDate.of( 2016 , 1 , 23 );
LocalDate stop = start.plusMonths( 1 );

int initialCapacity = Duration.between( start , stop ).toDays() ;
List<LocalDate> dates = new ArrayList<>( initialCapacity );

LocalDate date = start.minusDays( 1 );  // Start a day ahead.
while( date.isBefore( stop ) ) {
    date = date.with( org.threeten.extra.Temporals.nextWorkingDay() );
    // Double-check ending date as the `nextWorkingDay` adjuster could move us past the stop date.
    if( date.isBefore( stop ) ) { 
        dates.add( date ) ;
    }
}

प्रदर्शन

मैं इस पृष्ठ पर विभिन्न उत्तरों में विभिन्न दृष्टिकोण के प्रदर्शन के बारे में उत्सुक हूं। मैं केवल आधुनिक विचार कर रहा हूं java.time कोड, परेशानी विरासत का उपयोग कर कोड नहीं Date/Calendar कक्षाएं।

यहां चार विधियां हैं जो प्रत्येक दिन बीतने की संख्या लौटाती हैं।

एक में देखा गया चालाक गणित आधारित दृष्टिकोण का उपयोग करता है रोलैंड द्वारा जवाब

private long countWeekDaysMath ( LocalDate start , LocalDate stop ) {
    // Code taken from Answer by Roland.
    // https://stackoverflow.com/a/44942039/642706
    long count = 0;
    final DayOfWeek startW = start.getDayOfWeek();
    final DayOfWeek stopW = stop.getDayOfWeek();

    final long days = ChronoUnit.DAYS.between( start , stop );
    final long daysWithoutWeekends = days - 2 * ( ( days + startW.getValue() ) / 7 );

    //adjust for starting and ending on a Sunday:
    count = daysWithoutWeekends + ( startW == DayOfWeek.SUNDAY ? 1 : 0 ) + ( stopW == DayOfWeek.SUNDAY ? 1 : 0 );

    return count;
}

मेरे इस उत्तर में दो उपयोग दृष्टिकोण देखे गए: (ए) प्रत्येक तिथि पर जाएं, पारंपरिक लूप में एक-एक करके बढ़ाना।

private long countWeekDaysVisit ( LocalDate start , LocalDate stop ) {
    // Code taken from Answer by Basil Bourque.
    // https://stackoverflow.com/a/40369140/642706
    long count = 0;
    Set < DayOfWeek > weekend = EnumSet.of( DayOfWeek.SATURDAY , DayOfWeek.SUNDAY );
    LocalDate ld = start;
    while ( ld.isBefore( stop ) ) {
        if ( ! weekend.contains( ld.getDayOfWeek() ) ) { // If not weekend, collect this LocalDate.
            count++;
        }
        // Prepare for next loop.
        ld = ld.plusDays( 1 ); // Increment to next day.
    }
    return count;
}

... और, (बी) का उपयोग करना TemporalAdjuster कार्यान्वयन org.threeten.extra.Temporals.nextWorkingDay()

private long countWeekDaysAdjuster ( LocalDate start , LocalDate stop ) {
    // Code taken from Answer by Basil Bourque.
    // https://stackoverflow.com/a/40369140/642706
    long count = 0;
    Set < DayOfWeek > weekend = EnumSet.of( DayOfWeek.SATURDAY , DayOfWeek.SUNDAY );
    TemporalAdjuster nextWorkingDayTA = org.threeten.extra.Temporals.nextWorkingDay();
    LocalDate ld = start;
    if ( weekend.contains( ld.getDayOfWeek() ) ) {
        ld = ld.with( nextWorkingDayTA );
    }
    while ( ld.isBefore( stop ) ) {
        count++;
        // Prepare for next loop.
        ld = ld.with( nextWorkingDayTA ); // Increment to next working day (non-weekend day).
    }
    return count;
}

अंतिम में जावा स्ट्रीम दृष्टिकोण का उपयोग किया जाता है रविंद्र रणवाला द्वारा जवाब

private long countWeekDaysStream ( LocalDate start , LocalDate stop ) {
    // Code taken from the Answer by Ravindra Ranwala.
    // https://stackoverflow.com/a/51010738/642706
    long count = 0;
    Set < DayOfWeek > weekend = EnumSet.of( DayOfWeek.SATURDAY , DayOfWeek.SUNDAY );
    final long weekDaysBetween = start.datesUntil( stop )
                                     .filter( d -> ! weekend.contains( d.getDayOfWeek() ) )
                                     .count();
    return count;
}

और परीक्षण दोहन।

चेतावनियां: 

  • खैर, सूक्ष्म बेंचमार्किंग के बारे में सामान्य चेतावनी अविश्वसनीय या अवास्तविक निष्कर्षों के लिए प्रवण होती है।
  • काश मैं इसका उपयोग करना सीखा था JMH सूक्ष्म बेंचमार्किंग ढांचे
  • मुझे इस कोड में से किसी एक को अनुकूलित करने का प्रयास करने के लिए परेशान नहीं है। उदाहरण के लिए, असली काम में, TemporalAdjuster हमारी विधि के बाहर कैश किया जा सकता है।

दोहन ​​परीक्षण।

LocalDate start = LocalDate.of( 2018 , Month.JANUARY , 1 );
LocalDate stop = start.plusYears( 1 );

int runs = 100_000;

long go = System.nanoTime();
for ( int i = 1 ; i <= runs ; i++ ) {
    long count = this.countWeekDaysMath( start , stop );
}
long elapsedMath = ( System.nanoTime() - go );

go = System.nanoTime();
for ( int i = 1 ; i <= runs ; i++ ) {
    long count = this.countWeekDaysVisit( start , stop );
}
long elapsedVisit = ( System.nanoTime() - go );

go = System.nanoTime();
for ( int i = 1 ; i <= runs ; i++ ) {
    long count = this.countWeekDaysStream( start , stop );
}
long elapsedAdjuster = ( System.nanoTime() - go );

go = System.nanoTime();
for ( int i = 1 ; i <= runs ; i++ ) {
    long count = this.countWeekDaysStream( start , stop );
}
long elapsedStream = ( System.nanoTime() - go );

System.out.println( "math: " + elapsedMath + " each: " + ( elapsedMath / runs ) );
System.out.println( "visit: " + elapsedVisit + " each: " + ( elapsedVisit / runs ) );
System.out.println( "adjuster: " + elapsedAdjuster + " each: " + ( elapsedAdjuster / runs ) );
System.out.println( "stream: " + elapsedStream + " each: " + ( elapsedStream / runs ) );

ओरेकल जेडीके 10.0.1 और मेरे मैकबुक प्रो (सिएरा) पर चलते समय ThreeTen-अतिरिक्त संस्करण 1.3.2, मुझे परिणाम लगातार निम्नलिखित के करीब मिलते हैं। गणित समाधान दूसरों का एक छोटा सा अंश है कुछ सौ नैनो बनाम कई हजार, जैसा कि हम स्पष्ट रूप से उम्मीद करेंगे। अन्य तीनों में से, TemporalAdjuster सबसे लंबा है, हमेशा 10,000 से अधिक नैनो। यात्रा और धारा दोनों 10,000 नैनो के नीचे अच्छी तरह से आती हैं, यात्रा के मुकाबले यात्रा तेजी से तेज होती है। जैसा कि इंटर्ननेट के आसपास के अन्य उदाहरणों में देखा गया है, जावा स्ट्रीम आमतौर पर निफ्टी शॉर्ट कोड के लिए बनाते हैं जबकि अक्सर काफी लंबे समय तक चलते हैं, इस मामले में लगभग 20% लंबा है।

गणित: 1831330 9 प्रत्येक: 183

यहां जाएं: 708420626 प्रत्येक: 7084

समायोजक: 1002157240 प्रत्येक: 10021

धारा: 924724750 प्रत्येक: 9 247


जावा के बारे में

java.time फ्रेमवर्क 8 और बाद में बनाया गया है। ये कक्षाएं परेशानी पुरानी हैं विरासत जैसे समय-समय पर कक्षाएं java.util.Date, Calendar, और SimpleDateFormat

Joda समय परियोजना, अब में रखरखाव मोड, जावा.टाइम में माइग्रेशन की सलाह देता है।

और जानने के लिए, देखें ओरेकल ट्यूटोरियल। और कई उदाहरणों और स्पष्टीकरणों के लिए स्टैक ओवरफ़्लो खोजें। विशिष्टता है जेएसआर 310

जावा.टाइम कक्षाएं कहां प्राप्त करें?

  • जावा एसई 8 तथा एसई 9 और बादमें
    • निर्मित।
    • एक बंडल कार्यान्वयन के साथ मानक जावा एपीआई का हिस्सा।
    • जावा 9 कुछ मामूली विशेषताओं और फिक्सेस जोड़ता है।
  • जावा एसई 6 तथा एसई 7
    • जावा की अधिकांश कार्यक्षमता जावा 6 और 7 में बैक-पोर्ट की गई है ThreeTen-backport
  • एंड्रॉयड

ThreeTen-अतिरिक्त परियोजना अतिरिक्त कक्षाओं के साथ जावा.टाइम बढ़ाती है। यह परियोजना java.time के संभावित भविष्य के जोड़ों के लिए एक सिद्ध भूमि है। आपको यहां कुछ उपयोगी कक्षाएं मिल सकती हैं जैसे कि Interval, YearWeek, YearQuarter, तथा अधिक


3
2017-11-01 21:44



के बजाय LocalDate date = start ;, क्यों नहीं LocalDate date = LocalDate.from(start) तर्क को म्यूट करने से बचने के लिए? - Simon
@ सिमन द java.time कक्षाएं हैं अडिग, डिजाइन द्वारा। - Basil Bourque


do  while पियुष के समाधान में गलत है, यह होना चाहिए:

do {
    if (startCal.get(Calendar.DAY_OF_WEEK) != Calendar.SATURDAY && startCal.get(Calendar.DAY_OF_WEEK) != Calendar.SUNDAY) {
        ++workDays;
    }
    startCal.add(Calendar.DAY_OF_MONTH, 1);
} while (startCal.getTimeInMillis() < endCal.getTimeInMillis());

2
2018-03-27 04:56





लूपिंग के बिना यह मेरा उदाहरण है। एल्गोरिदम समान है 卢 声 远 Shengyuan लुस एक लेकिन मैंने जोडाटाइम की कुछ विशेषताओं का उपयोग किया।

public static int getNumberOfBusinessDays(@Nonnull LocalDate from, @Nonnull LocalDate to) {
    int fromDateDayOfWeek = from.getDayOfWeek();
    int toDateDayOfWeek = to.getDayOfWeek();

    int daysWithoutWeekends = 5 * Weeks.weeksBetween(
            from.withDayOfWeek(DateTimeConstants.MONDAY), to).getWeeks();

    if (fromDateDayOfWeek == DateTimeConstants.SUNDAY) {
        fromDateDayOfWeek = DateTimeConstants.SATURDAY;
    }
    if (toDateDayOfWeek == DateTimeConstants.SUNDAY) {
        toDateDayOfWeek = DateTimeConstants.SATURDAY;
    }

    return daysWithoutWeekends - (fromDateDayOfWeek - toDateDayOfWeek);
}

2
2017-07-27 07:23





लगभग सभी समाधान काफी अप्रचलित और कथात्मक हैं। हालांकि यहां एक बहुत संघनित और पठनीय समाधान है।

यह दृष्टिकोण एक का उपयोग करता है जावा स्ट्रीम द्वारा प्रदान की गई LocalDate::datesUntil जावा 9 और बाद में बनाई गई विधि।

LocalDate startDate = LocalDate.of(2018, 5, 2);
LocalDate endDate = LocalDate.now();
Set<DayOfWeek> weekend = EnumSet.of(DayOfWeek.SATURDAY, DayOfWeek.SUNDAY);
final long weekDaysBetween = startDate.datesUntil(endDate)
        .filter(d -> !weekend.contains(d.getDayOfWeek()))
        .count();

.datesUntil तिथियों की एक क्रमिक आदेशित धारा देता है।   लौटाई गई धारा इस तिथि से शुरू होती है (समावेशी) और जाती है   1 दिन के एक वृद्धिशील चरण से अंत एक्सक्लूसिव (अनन्य)।

तब सभी शनिवार और रविवार को फ़िल्टर किया जाता है। अंतिम चरण शेष सप्ताह के दिनों की गिनती प्राप्त करना है।

जावा -9 एक साल पहले जारी किया गया है, क्योंकि इसका उपयोग करने से अब मुझे उचित लगता है।


2
2018-06-24 14:15



मुझे यह जवाब सबसे सरल और सबसे कम कोड के लिए पसंद है। लेकिन यह सबसे धीमी गति से है: (ए) प्रत्येक तारीख पर विचार किया जा रहा है, जबकि कुछ अन्य उत्तर प्रत्येक तारीख के बिना कुल गणना करने में चालाक होने की कोशिश कर रहे थे। (बी) जावा स्टीम अक्सर वैकल्पिक कोड से धीमे होते हैं, कभी-कभी कई गुना से। इसलिए यदि बड़ी मात्रा में डेटा का उपयोग करना या अक्सर चलाना, प्रदर्शन के लिए परीक्षण करना। अन्यथा मैं इस दृष्टिकोण का उपयोग कम मात्रा में डेटा के लिए कम बार चलाता था। - Basil Bourque
@ बेसिलबॉर्क मैं कुछ हद तक आपसे सहमत हूं। हां यह समाधान हर तारीख को मानता है। लेकिन यह दृष्टिकोण बहुत समानांतर मित्रवत है। इसलिए, यदि आवश्यक हो तो हम समानांतर में इसे निष्पादित करके समानांतर गति प्राप्त कर सकते हैं। - Ravindra Ranwala
कोरों में समांतरता निष्पादन के समय समाप्त हो जाती है (दीवार घड़ी का समय) लेकिन करता है नहीं सीपीयू पर बोझ कम करें, मान लें कि आपके पास रनटाइम पर कोर उपलब्ध हैं। दरअसल, समांतरता कहते हैं समांतर काम को समन्वयित करने के ऊपरी हिस्से के लिए, सीपीयू बोझ के लिए। - Basil Bourque
इस धागे ने मेरी जिज्ञासा पकड़ी। तो मैंने रोलैंड के गणित-आधारित दृष्टिकोण के खिलाफ अपने जावा स्ट्रीम दृष्टिकोण को आजमाया, और मेरे दो दृष्टिकोण प्रत्येक तारीख पर जाकर और एक का उपयोग कर TemporalAdjuster। रोलैंड का गणित, बिना किसी तुलना के, एक लंबे शॉट से जीतता है। परंपरागत पाश में प्रत्येक तिथि पर जाने से आपकी स्ट्रीम दृष्टिकोण लगभग 20% धीमी है। लेकिन मेरे TemporalAdjuster दृष्टिकोण हमेशा सबसे धीमा था। मेरे सभी कोड और परिणाम "प्रदर्शन" खंड में जोड़ा गया देखें मेरा जवाब। - Basil Bourque
@ बेसिलबर्क हां, समानांतर निष्पादन परिणाम को तेजी से गणना करने के लिए अधिक CPU चक्र लेता है। हालांकि यह एक महान बेंचमार्क था। - Ravindra Ranwala


startCal.add पर जोड़ना चाहिए Calendar.DATE क्षेत्र, नहीं Calendar.DAY_OF_MONTH, मैं Decemeber / जनवरी अवधि के साथ अजीब परिणाम मिल रहा था।


1
2017-08-28 06:47



मुझे नहीं लगता कि यह सच है, कैलेंडर.डेट कैलेंडर के लिए समानार्थी है। DAY_OF_MONTH - mbosecke