जावा

Question

में 2 दी गई तिथियों के बीच सभी दिन उत्पन्न करना मैं तिथियों की एक सरणी प्राप्त करने की कोशिश कर रहा हूं, जबकि मेरा इनपुट 'से'/'टू' संरचना है। तो मेरी इनपुट है:

String date1 = "2014-01-01"; 
String date2 = "2014-05-01"; 

मेरे उत्पादन DATE1 और DATE2 के बीच सभी तिथियों के साथ एक ArrayList होना चाहिए। मैं पहले से ही इस बात के लिए देखा है, लेकिन मैं केवल 2 दिनांकों के बीच अंतर के बारे में सवाल मिल सकता है:

SimpleDateFormat myFormat = new SimpleDateFormat("dd MM yyyy"); 
String inputString1 = "23 01 1997"; 
String inputString2 = "27 04 1997"; 

try { 
    Date date1 = myFormat.parse(inputString1); 
    Date date2 = myFormat.parse(inputString2); 
    long diff = date2.getTime() - date1.getTime(); 
    System.out.println ("Days: " + TimeUnit.DAYS.convert(diff,TimeUnit.MILLISECONDS)); 
} catch (ParseException e) { 
e.printStackTrace(); 
} 

कोई संकेत या सुझाव? अन्य सभी प्रश्न आईओएस या एसक्यूएल के लिए हैं।

Answer 1

JodaTime पर एक नज़र डालें: http://joda-time.sourceforge.net/apidocs/org/joda/time/DateTime.html

DateTime dateTime1 = new DateTime(date1); 
DateTime dateTime2 = new DateTime(date2); 

List<Date> allDates = new ArrayList(); 

while(dateTime1.before(dateTime2)){ 
    allDates.add(dateTime1.toDate()); 
    dateTime1 = dateTime1.plusDays(1); 
} 

Answer 2

आप Calendar उपयोग कर सकते हैं आप तीसरे पक्ष के पुस्तकालयों का उपयोग नहीं करना चाहते हैं:

चेक here a working demo।

public static void main(String[] args) throws Exception { 
    SimpleDateFormat myFormat = new SimpleDateFormat("dd MM yyyy"); 
    String inputString1 = "23 01 1997"; 
    String inputString2 = "27 04 1997"; 
    ArrayList<Date> dates = new ArrayList<Date>(); 

    try { 
     Date date1 = myFormat.parse(inputString1); 
     Calendar c1 = DateToCalendar(date1); 
     Date date2 = myFormat.parse(inputString2); 
     Calendar c2 = DateToCalendar(date2); 

     while (!areEqualDate(c1, c2)) { 
      dates.add(c1.getTime()); 
      System.out.println (c1.getTime()); 
      c1.add(Calendar.DAY_OF_YEAR, 1); 
     } 
    } catch (ParseException e) { 
     e.printStackTrace(); 
    } 


    // ArrayList<Date> dates >> contain all dates between both given days. 
} 


private static boolean areEqualDate(Calendar c1, Calendar c2) { 
    if (c1.get(Calendar.YEAR) != c2.get(Calendar.YEAR)) return false; 
    if (c1.get(Calendar.MONTH) != c2.get(Calendar.MONTH)) return false; 
    if (c1.get(Calendar.DAY_OF_YEAR) != c2.get(Calendar.DAY_OF_YEAR)) return false; 
    return true; 
} 

public static Calendar DateToCalendar(Date date) { 
    Calendar cal = Calendar.getInstance(); 
    cal.setTime(date); 
    return cal; 
} 

Answer 3

मैं JodaTime पसंद है, लेकिन यह भी java.util.Calendar का उपयोग करके 3 पार्टी पुस्तकालयों के बिना किया जा सकता है। Calendar ऑब्जेक्ट को देखते हुए, कोई कैलेंडर नियमों को सम्मानित करते समय दिनांक के कुछ फ़ील्ड को बढ़ाने के लिए add विधि का उपयोग कर सकता है (जैसे 31 जनवरी को 1 दिन जोड़ना आपको 1 फरवरी तक नहीं मिलता है, 32 जनवरी तक नहीं)।

पहले मिल एक Calendar वस्तु प्रत्येक में दिनांक, सही कालानुक्रमिक क्रम इतना जोड़ने में बाद में सही दिशा में जा रहा है:

Calendar cStart = Calendar.getInstance(), 
      cStop = Calendar.getInstance(); 

    if (date1.before(date2)) { 
     cStart.setTime(date1); 
     cStop.setTime(date2); 
    } else { 
     cStart.setTime(date2); 
     cStop.setTime(date1); 

date1 और date2 सादगी के लिए, आपके सवाल से Date वस्तुओं पार्स हैं खातिर।

इसके बाद, पर एक अनुदेश "के दिन के अनुसार साल में 1 जोड़" जब तक यह रोक तारीख से परे आप हो जाता है पाश:

do { 
     System.out.println(pretty(cStart)); 
     cStart.add(Calendar.DAY_OF_YEAR, 1); 
} while (cStart.before(cStop)); 

और अंत में बंद तारीख

System.out.println(pretty(cStop)); 

pretty() प्रिंट एसडीएफ के माध्यम से कैलेंडर भेजने के लिए बस कुछ मिनी विधि है, जैसे कि आप स्ट्रिंग्स को पहली जगह पर पार्स करने के लिए इस्तेमाल करते हैं।

यह समाधान दिनांक सीमा को प्रिंट और स्टॉप तिथियों सहित प्रिंट करेगा, और किनारे के मामलों (जैसे date1==date2) के आसपास कुछ tweaking की आवश्यकता हो सकती है। प्रारंभ और बंद तिथियों को बाहर करने के लिए आसानी से अनुकूलित किया जा सकता है। पाठ्यक्रम के एकत्रीकरण के लिए प्रिंटिंग को बदला जा सकता है। कैलेंडर से डेट ऑब्जेक्ट प्राप्त करने के लिए, getTime() विधि का उपयोग करें (एक स्नैपशॉट देता है, लाइव संदर्भ नहीं)।

प्रासंगिक (Gregorian)Calendar के लिए प्रलेखन पाया जा सकता है।

Answer 4

मैं पहले से ही पता है कि ओपी जावा 8 का उपयोग नहीं है, लेकिन यहां वर्तमान समाधान है - जावा पुर्नोत्थान किया गया है और नए java.time एपीआई इस संबंध में हर कल्पनीय काम करता है:

//change these values : 
LocalDate ld1 = LocalDate.ofEpochDay(0); 
LocalDate ld2 = LocalDate.now(); 

//do NOT change these: 
final LocalDate begin = ld1.isBefore(ld2) ? ld1 : ld2; 
final LocalDate end = ld2.isAfter(ld1) ? ld2 : ld1; 

for (int i = 0; i < begin.until(end, ChronoUnit.DAYS); i++) { 
    final LocalDate curDate = begin.plusDays(i); 
    System.out.println("current date : " + curDate); 
} 

हो जाएगा ताकि उत्पादन हर वैध दो तिथियों के बीच दिन जबकि अन्य समाधानों में से अधिकांश आपको अमान्य वाले भी प्रदान करेंगे; बात सुनती है: अस्थायी गणना समय-समय पर स्वतंत्र डेटा पर की जानी चाहिए - आउटपुट दूसरी तरफ टाइमज़ोन और/या क्रोनोलॉजी-निर्भर हो सकता है। Thats क्यों java.time.format जैसे पैकेज हैं - बस अपने चुने हुए क्षेत्र के लिए अपने समय/दिनांक मानों और प्रारूप की गणना करें ... यह कैसे सही ढंग से किया गया है।

आप अस्थायी इनपुट कन्वर्ट करने के लिए वहाँ भी कर रहे हैं समय-एपीआई में उपयोगी काम करता है, मैं इस विषय पर एक गहन ट्यूटोरियल करने की सलाह देते की जरूरत है, कुछ अच्छे परिचय this और विशेष रूप से that हो सकता है:

वहाँ समय का प्रतिनिधित्व करने के दो बुनियादी तरीके हैं। एक तरीका मानव शब्द के रूप में संदर्भित करता है, जिसे मानव समय, जैसे वर्ष, महीना, दिन, घंटे, मिनट और सेकंड के रूप में जाना जाता है। दूसरी तरफ, मशीन समय, माप एक उत्पत्ति से एक समयरेखा के साथ लगातार, नैनोसेकंद संकल्प में युग कहा जाता है। डेट-टाइम पैकेज तिथि और समय का प्रतिनिधित्व करने के लिए कक्षाओं की समृद्ध सरणी प्रदान करता है। डेट-टाइम एपीआई में कुछ कक्षाएं मशीन समय का प्रतिनिधित्व करने का इरादा रखती हैं, और अन्य मानव समय का प्रतिनिधित्व करने के लिए अधिक उपयुक्त हैं।

Answer 5

नीचे तारीखों के सरणी प्राप्त करने के लिए कोड है दो स्ट्रिंग तारीख के बीच।

import java.text.ParseException; 
import java.text.SimpleDateFormat; 
import java.util.ArrayList; 
import java.util.Calendar; 
import java.util.Date; 
import java.util.GregorianCalendar; 
import java.util.List; 
public class DateFormatExample { 
    public static void main(String[] args) { 
     // TODO Auto-generated method stub 
     SimpleDateFormat myFormat = new SimpleDateFormat("yyyy-MM-dd"); 
     SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd"); 
     String date1 = "2014-01-01"; 
     String date2 = "2014-05-01"; 
     try { 
      Date d1 = myFormat.parse(date1); 
      Date d2 = myFormat.parse(date2); 
      List<Date> allDates = new ArrayList<Date>(); 
      List<String> allDatesString = new ArrayList<String>(); 
      while(d1.before(d2)){ 
       d1 = addDays(d1, 1); 
       allDates.add(d1); 
       allDatesString.add(formatter.format(d1)); 
      } 
      System.out.println(allDates); 
      System.out.println(allDatesString); 
     } catch (ParseException e) { 
     e.printStackTrace(); 
     } 
    } 
    private static Date addDays(Date d1, int i) { 
     GregorianCalendar cal = new GregorianCalendar(); 
     cal.setTime(d1); 
     cal.add(Calendar.DATE, 1); 
     return cal.getTime(); 
    } 

} 

Answer 6

यदि आप गुवा का उपयोग कर रहे हैं, तो इस समस्या का एक बहुत ही सुरुचिपूर्ण समाधान है।

अमरूद में दो साफ वर्ग हैं, जैसे कि Range और ContiguousSet, जो आपको वास्तव में आवश्यकतानुसार लागू करता है: पहला मूल्यों की श्रृंखलाओं पर चलता है, और दूसरा - एक सीमा को अलग-अलग मूल्यों के सेट में परिवर्तित करने में सक्षम होता है।

LocalDate start = LocalDate.parse("2015-01-01"); 
LocalDate end = LocalDate.parse("2019-02-01"); 
Range<LocalDate> range = Range.closed(start, end); //Creates a "closed" range, that is both dates are inclusive. There are also options like "openClosed", "closedOpen" and "open" 
final Set<LocalDate> daySet = ContiguousSet.create(range, LocalDateDomain.INSTANCE); //Create a "virtual" set of days in given the range. "virtual" part means that if you create a set of 10 thousand years, it will not eat your memory at all 
for (LocalDate day : daySet) { 
    //...operation... 
} 

व्यक्तिगत रूप से, मैं वास्तव में, इस तरह से पसंद करते हैं के रूप में यह समाप्त समझ के साथ कुछ समस्याएं/खुला पर्वतमाला बंद कर दिया, और पढ़ने के लिए कोड बहुत आसान है और बनाता है: दोनों (एक साथ JodaTime के साथ) के उपयोग के

उदाहरण समझते हैं, प्रदर्शन पर कोई प्रभाव नहीं पड़ते हैं। साथ ही, यह किसी भी प्रकार की तिथियों, किसी भी पुस्तकालय (आप YodaTime को जावा 8 तिथियों या यहां तक ​​कि जावा 7- दिनांक-आधारित कार्यान्वयन में भी स्वैप कर सकते हैं) के साथ काम करता है।

इसके अलावा, यह आपको चौराहे, यूनियनों, श्रेणियों की फैलाव, अविश्वसनीय रूप से तेज़ "युक्त" जैसी श्रेणियों पर कुछ साफ संचालन करने की अनुमति देता है।

केवल कमियां हैं: अमरूद पर

1. निर्भरता।
2. एक विशेष "DiscreteDomain" कक्षा बनाने की आवश्यकता है, जिसे गुवा समझने के लिए उपयोग करता है कि एक तिथि समाप्त होती है और अन्य शुरू होता है। LocalDateDomain कार्यान्वयन के

उदाहरण जो अमरूद और JodaTime के बीच एक पुल के रूप में संचालित:

public class LocalDateDomain extends DiscreteDomain<LocalDate> { 
    public static final LocalDateDomain INSTANCE = new LocalDateDomain(); 

    @Override 
    public LocalDate next(LocalDate value) { 
     return value.plusDays(1); 
    } 

    @Override 
    public LocalDate previous(LocalDate value) { 
     return value.minusDays(1); 
    } 

    @Override 
    public long distance(LocalDate start, LocalDate end) { 
     return Days.daysBetween(start, end).getDays(); 
    } 
}