कैसे जावा में एक तारीख को पवित्रता की जाँच करें [बंद]

Question 1

बंद हो गया । इस प्रश्न पर अधिक ध्यान देने की आवश्यकता है । यह वर्तमान में उत्तर स्वीकार नहीं कर रहा है।

इस प्रश्न को सुधारना चाहते हैं? प्रश्न को अपडेट करें ताकि यह इस पोस्ट को संपादित करके केवल एक समस्या पर केंद्रित हो ।

1 साल पहले बंद हुआ ।

इस प्रश्न को सुधारें

मुझे यह उत्सुक लगता है कि Dateजावा में वस्तुओं को बनाने का सबसे स्पष्ट तरीका हटा दिया गया है और ऐसा लगता है कि "वैकल्पिक रूप से प्रतिस्थापित" किया गया है ताकि लिनेन कैलेंडर का उपयोग न किया जा सके।

आप कैसे जांचते हैं कि दिन, महीने और वर्ष के संयोजन के रूप में दी गई तारीख एक वैध तिथि है?

उदाहरण के लिए, 2008-02-31 (जैसा कि yyyy-mm-dd में) एक अमान्य तारीख होगी।

Question 2

वर्तमान तरीका कैलेंडर वर्ग का उपयोग करना है। इसमें सेटेलिएंट विधि है जो तिथि और थ्रेड और अपवाद को मान्य करेगी यदि यह आपके उदाहरण के अनुसार सीमा से बाहर है।

जोड़ना भूल गए: यदि आपको कैलेंडर का उदाहरण मिलता है और अपनी तिथि का उपयोग करने का समय निर्धारित है, तो यह है कि आपको सत्यापन कैसे मिलेगा।

Calendar cal = Calendar.getInstance();
cal.setLenient(false);
cal.setTime(yourDate);
try {
    cal.getTime();
}
catch (Exception e) {
  System.out.println("Invalid date");
}

Question 3

कुंजी df.setLenient (झूठी) है; । यह साधारण मामलों के लिए पर्याप्त से अधिक है। यदि आप अधिक मजबूत (मुझे संदेह है) और / या वैकल्पिक लाइब्रेरियों जैसे जॉडा-टाइम की तलाश कर रहे हैं, तो उपयोगकर्ता "टार्डेट" के उत्तर को देखें।

final static String DATE_FORMAT = "dd-MM-yyyy";

public static boolean isDateValid(String date) 
{
        try {
            DateFormat df = new SimpleDateFormat(DATE_FORMAT);
            df.setLenient(false);
            df.parse(date);
            return true;
        } catch (ParseException e) {
            return false;
        }
}

Question 4

जैसा कि @ मैग्लोब द्वारा दिखाया गया है, मूल दृष्टिकोण सिंपलडेटफार्मैट.पर्स का उपयोग करके स्ट्रिंग से तारीख तक रूपांतरण का परीक्षण करना है । यह 2008-02-31 जैसे अमान्य दिन / महीने के संयोजन को पकड़ लेगा।

हालाँकि, SimpleDateFormat.parse के बाद से शायद ही कभी पर्याप्त रूप से उदार है। आप के साथ संबंध हो सकता है दो व्यवहार कर रहे हैं:

दिनांक स्ट्रिंग में अमान्य वर्ण आश्चर्यजनक रूप से, 2008-02-2x उदाहरण के लिए स्थानीय प्रारूप = "yyyy-MM-dd" के साथ एक वैध तारीख के रूप में "पास" होगा। यहाँ तक कि जब।

वर्ष: 2, 3 या 4 अंक? आप डिफ़ॉल्ट SimpleDateFormat व्यवहार (जो "12-02-31" की व्याख्या अलग-अलग करने की अनुमति देने के बजाय 4-अंकीय वर्ष लागू करना चाह सकते हैं, यह निर्भर करता है कि आपका प्रारूप "yyyy-MM-dd" या "yy-MM-dd" है) )

मानक पुस्तकालय के साथ एक सख्त समाधान

तो एक पूरी स्ट्रिंग टू डेट टेस्ट इस तरह दिख सकता है: रेगेक्स मैच का एक संयोजन, और फिर एक मजबूर तारीख रूपांतरण। रेगेक्स के साथ चाल इसे स्थानीय रूप से अनुकूल बनाने के लिए है।

  Date parseDate(String maybeDate, String format, boolean lenient) {
    Date date = null;

    // test date string matches format structure using regex
    // - weed out illegal characters and enforce 4-digit year
    // - create the regex based on the local format string
    String reFormat = Pattern.compile("d+|M+").matcher(Matcher.quoteReplacement(format)).replaceAll("\\\\d{1,2}");
    reFormat = Pattern.compile("y+").matcher(reFormat).replaceAll("\\\\d{4}");
    if ( Pattern.compile(reFormat).matcher(maybeDate).matches() ) {

      // date string matches format structure, 
      // - now test it can be converted to a valid date
      SimpleDateFormat sdf = (SimpleDateFormat)DateFormat.getDateInstance();
      sdf.applyPattern(format);
      sdf.setLenient(lenient);
      try { date = sdf.parse(maybeDate); } catch (ParseException e) { }
    } 
    return date;
  } 

  // used like this:
  Date date = parseDate( "21/5/2009", "d/M/yyyy", false);

ध्यान दें कि रेगेक्स मानता है कि प्रारूप स्ट्रिंग में केवल दिन, महीने, वर्ष और विभाजक वर्ण होते हैं। इसके अलावा, प्रारूप किसी भी स्थानीय प्रारूप में हो सकता है: "d / MM / yy", "yyyy-MM-dd", और इसी तरह। वर्तमान लोकेल के लिए प्रारूप स्ट्रिंग इस तरह प्राप्त की जा सकती है:

Locale locale = Locale.getDefault();
SimpleDateFormat sdf = (SimpleDateFormat)DateFormat.getDateInstance(DateFormat.SHORT, locale );
String format = sdf.toPattern();

Joda समय - बेहतर वैकल्पिक?

मैं हाल ही में joda समय के बारे में सुन रहा हूं और सोचा था कि मैं तुलना करूंगा। दो बिंदु:

SimpleDateFormat के विपरीत, दिनांक स्ट्रिंग में अमान्य वर्णों के बारे में बेहतर लगता है
अभी तक इसके साथ 4-अंकीय वर्षों को लागू करने का एक तरीका नहीं देख सकता (लेकिन मुझे लगता है कि आप इस कार्य के लिए अपना खुद का DateTimeFormatter बना सकते हैं )

यह उपयोग करने के लिए काफी सरल है:

import org.joda.time.format.*;
import org.joda.time.DateTime;

org.joda.time.DateTime parseDate(String maybeDate, String format) {
  org.joda.time.DateTime date = null;
  try {
    DateTimeFormatter fmt = DateTimeFormat.forPattern(format);
    date =  fmt.parseDateTime(maybeDate);
  } catch (Exception e) { }
  return date;
}

Question 5

आप SimpleDateFormat का उपयोग कर सकते हैं

उदाहरण के लिए कुछ इस तरह:

boolean isLegalDate(String s) {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    sdf.setLenient(false);
    return sdf.parse(s, new ParsePosition(0)) != null;
}

Question 6

tl; डॉ

का प्रयोग करें सख्त मोड पर java.time.DateTimeFormatterपार्स एक करने के लिए LocalDate। के लिए ट्रैप DateTimeParseException।

LocalDate.parse(                   // Represent a date-only value, without time-of-day and without time zone.
    "31/02/2000" ,                 // Input string.
    DateTimeFormatter              // Define a formatting pattern to match your input string.
    .ofPattern ( "dd/MM/uuuu" )
    .withResolverStyle ( ResolverStyle.STRICT )  // Specify leniency in tolerating questionable inputs.
)

पार्स करने के बाद, आप उचित मूल्य की जांच कर सकते हैं। उदाहरण के लिए, पिछले एक सौ वर्षों के भीतर एक जन्म तिथि।

birthDate.isAfter( LocalDate.now().minusYears( 100 ) )

विरासत की तारीखों की कक्षाओं से बचें

जावा के शुरुआती संस्करणों के साथ शिप किए गए परेशान पुराने दिनांक-समय वर्गों का उपयोग करने से बचें। अब java.time कक्षाओं द्वारा इसे दबा दिया गया ।

`LocalDate`और `DateTimeFormatter`&`ResolverStyle`

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

String input = "31/02/2000";
DateTimeFormatter f = DateTimeFormatter.ofPattern ( "dd/MM/uuuu" );
try {
    LocalDate ld = LocalDate.parse ( input , f );
    System.out.println ( "ld: " + ld );
} catch ( DateTimeParseException e ) {
    System.out.println ( "ERROR: " + e );
}

java.time.DateTimeFormatterकक्षा में परिभाषित तीन उदारता मोड से किसी के साथ तार पार्स करने के लिए सेट किया जा सकता ResolverStyleenum। हम प्रत्येक कोड को आजमाने के लिए उपरोक्त कोड में एक लाइन डालते हैं।

f = f.withResolverStyle ( ResolverStyle.LENIENT );

परिणाम:

ResolverStyle.LENIENT
ld: 2000-03-02
ResolverStyle.SMART
ld: 2000-02-29
ResolverStyle.STRICT
त्रुटि: java.time.format.DateTimeParseException: पाठ '31 / 02/2000 'को पार्स नहीं किया जा सकता: अमान्य दिनांक' FEBRUARY 31 '

हम देख सकते हैं कि ResolverStyle.LENIENTमोड में, अमान्य दिनांक को समतुल्य दिनों के लिए आगे ले जाया जाता है। में ResolverStyle.SMARTमोड (डिफ़ॉल्ट), एक तार्किक निर्णय महीने के भीतर और महीने के अंतिम दिन संभव के साथ जा रहा तारीख को रखने के लिए किया जाता है, एक लीप वर्ष में 29 फ़रवरी, वहाँ के रूप में उस महीने में कोई 31 दिन है। ResolverStyle.STRICTमोड एक अपवाद शिकायत ऐसी कोई तारीख है कि वहाँ फेंकता है।

ये तीनों आपकी व्यावसायिक समस्या और नीतियों के आधार पर उचित हैं। आपके मामले में लगता है कि आप सख्त मोड को समायोजित करने के बजाय अमान्य दिनांक को अस्वीकार करना चाहते हैं।

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

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

अधिक जानने के लिए, Oracle ट्यूटोरियल देखें । और कई उदाहरणों और स्पष्टीकरणों के लिए ढेर अतिप्रवाह खोजें। विशिष्टता JSR 310 है ।

Joda समय परियोजना, अब में रखरखाव मोड , प्रवास करने की सलाह देता java.time कक्षाएं।

आप अपने डेटाबेस से सीधे java.time वस्तुओं का आदान-प्रदान कर सकते हैं । JDBC 4.2 या उसके बाद के JDBC ड्राइवर के अनुपालन का उपयोग करें । तार की कोई जरूरत नहीं, कक्षाओं की कोई जरूरत नहीं ।java.sql.*

Java.time कक्षाएं कहाँ से प्राप्त करें?

जावा एसई 8 , जावा एसई 9 , जावा एसई 10 , जावा एसई 11 , और बाद में - बंडल कार्यान्वयन के साथ मानक जावा एपीआई का हिस्सा।
- जावा 9 में कुछ छोटी विशेषताएं और सुधार शामिल हैं।
जावा एसई 6 और जावा एसई 7
- जावा- टाइम की अधिकांश कार्यक्षमता थ्री-बैक-बैकपोर्ट में जावा 6 और 7 में वापस पोर्ट की गई है ।
एंड्रॉयड
- Java.time कक्षाओं के एंड्रॉइड बंडल कार्यान्वयन के बाद के संस्करण ।
- पहले एंड्रॉइड (<26) के लिए, थ्रीटेनबप प्रोजेक्ट थ्रीटेन-बैकपोर्ट (ऊपर उल्लिखित) को एडाप्ट करता है । देखें कि थ्रीटेनब का उपयोग कैसे करें… ।

ThreeTen-अतिरिक्त परियोजना अतिरिक्त कक्षाओं के साथ java.time फैली हुई है। यह परियोजना java.time के लिए भविष्य के संभावित अतिरिक्त के लिए एक साबित जमीन है। आप यहाँ कुछ उपयोगी वर्गों जैसे मिल सकता है Interval, YearWeek, YearQuarter, और अधिक ।

Question 7

java.time

साथ दिनांक और समय एपीआई ( java.time वर्ग) जावा 8 में बनाया गया और बाद में, आप उपयोग कर सकते LocalDateवर्ग।

public static boolean isDateValid(int year, int month, int day) {
    boolean dateIsValid = true;
    try {
        LocalDate.of(year, month, day);
    } catch (DateTimeException e) {
        dateIsValid = false;
    }
    return dateIsValid;
}

Question 8

मानक पुस्तकालय का उपयोग कर एक वैकल्पिक सख्त समाधान निम्नलिखित कार्य करना है:

1) अपने पैटर्न का उपयोग करके एक सख्त SimpleDateFormat बनाएं

2) प्रारूप ऑब्जेक्ट का उपयोग करके उपयोगकर्ता द्वारा दर्ज मूल्य को पार्स करने का प्रयास

3) यदि सफल, एक ही तिथि प्रारूप ((1) से) का उपयोग करके परिणाम (2) से सुधार

4) मूल, उपयोगकर्ता द्वारा दर्ज मूल्य के खिलाफ सुधारित तारीख की तुलना करें। यदि वे समान हैं तो दर्ज किया गया मान आपके पैटर्न से सख्ती से मेल खाता है।

इस तरह, आपको जटिल नियमित अभिव्यक्तियाँ बनाने की ज़रूरत नहीं है - मेरे मामले में मुझे सिंपलडेटाफोर्मैट के सभी पैटर्न सिंटैक्स का समर्थन करने की आवश्यकता है, बजाय कुछ दिनों, महीनों और वर्षों जैसे कुछ प्रकारों तक सीमित रहने की।

Question 9

अपनी टिप्पणी में ceklock द्वारा बताई गई समस्या को ठीक करने के लिए अरविंद के उत्तर पर बिल्डिंग , मैंने यह सत्यापित करने के लिए एक विधि जोड़ी कि इसमें कोई अमान्य वर्ण नहीं है।dateString

यहाँ है मैं कैसे:

private boolean isDateCorrect(String dateString) {
    try {
        Date date = mDateFormatter.parse(dateString);
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return matchesOurDatePattern(dateString);    //added my method
    }
    catch (ParseException e) {
        return false;
    }
}

/**
 * This will check if the provided string matches our date format
 * @param dateString
 * @return true if the passed string matches format 2014-1-15 (YYYY-MM-dd)
 */
private boolean matchesDatePattern(String dateString) {
    return dateString.matches("^\\d+\\-\\d+\\-\\d+");
}

Question 10

मुझे लगता है कि सबसे सरल एक स्ट्रिंग को डेट ऑब्जेक्ट में बदलने और इसे वापस स्ट्रिंग में बदलने के लिए है। यदि दोनों तार अभी भी मेल खाते हैं तो दी गई तारीख स्ट्रिंग ठीक है।

public boolean isDateValid(String dateString, String pattern)
{   
    try
    {
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
        if (sdf.format(sdf.parse(dateString)).equals(dateString))
            return true;
    }
    catch (ParseException pe) {}

    return false;
}

Question 11

मैं आपको org.apache.commons.validator.GenericValidatorअपाचे से कक्षा का उपयोग करने का सुझाव देता हूं ।

GenericValidator.isDate(String value, String datePattern, boolean strict);

नोट: सख्त - तारीख का सटीक मिलान होना या न होना।

Question 12

यह मानते हुए कि वे दोनों स्ट्रिंग्स हैं (अन्यथा वे पहले से ही वैध दिनांक होंगे), यहां एक तरीका है:

package cruft;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateValidator
{
    private static final DateFormat DEFAULT_FORMATTER;

    static
    {
        DEFAULT_FORMATTER = new SimpleDateFormat("dd-MM-yyyy");
        DEFAULT_FORMATTER.setLenient(false);
    }

    public static void main(String[] args)
    {
        for (String dateString : args)
        {
            try
            {
                System.out.println("arg: " + dateString + " date: " + convertDateString(dateString));
            }
            catch (ParseException e)
            {
                System.out.println("could not parse " + dateString);
            }
        }
    }

    public static Date convertDateString(String dateString) throws ParseException
    {
        return DEFAULT_FORMATTER.parse(dateString);
    }
}

यहाँ मैं प्राप्त उत्पादन है:

java cruft.DateValidator 32-11-2010 31-02-2010 04-01-2011
could not parse 32-11-2010
could not parse 31-02-2010
arg: 04-01-2011 date: Tue Jan 04 00:00:00 EST 2011

Process finished with exit code 0

जैसा कि आप देख सकते हैं, यह आपके दोनों मामलों को अच्छी तरह से संभालता है।

Question 13

यह मेरे लिए बहुत अच्छा काम कर रहा है। बेन द्वारा ऊपर सुझाया गया दृष्टिकोण।

private static boolean isDateValid(String s) {
    SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
    try {
        Date d = asDate(s);
        if (sdf.format(d).equals(s)) {
            return true;
        } else {
            return false;
        }
    } catch (ParseException e) {
        return false;
    }
}

Question 14

SimpleDateFormat की तरह लग रहा है सेटलाइनेंट (झूठा) के बाद भी पैटर्न की सख्ती से जाँच नहीं कर रहा है ; विधि इस पर लागू होती है, इसलिए मैंने नीचे दी गई पद्धति का उपयोग यह प्रमाणित करने के लिए किया है कि इनपुट तिथि मान्य तिथि है या आपूर्ति किए गए पैटर्न के अनुसार नहीं।

import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
public boolean isValidFormat(String dateString, String pattern) {
    boolean valid = true;
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
    try {
        formatter.parse(dateString);
    } catch (DateTimeParseException e) {
        valid = false;
    }
    return valid;
}

Question 15

SimpleDateFormat के उपयोग पर दो टिप्पणियाँ।

इसे स्थिर उदाहरण के रूप में घोषित किया जाना चाहिए, यदि स्थिर पहुंच के रूप में घोषित किया जाना चाहिए, क्योंकि यह थ्रेड सुरक्षित नहीं है

IME जो कि बेहतर है कि किसी तिथि के प्रत्येक पारे के लिए एक इंस्टेंटिंग को इंस्टेंट करना।

Question 16

डेट पार्सिंग के उपरोक्त तरीके अच्छे हैं, मैंने मौजूदा तरीकों में नया चेक जोड़ा है जो कि फॉर्मेटर का उपयोग करके मूल तिथि के साथ परिवर्तित तिथि की दोहरी जांच करता है, इसलिए यह लगभग हर मामले के लिए काम करता है जैसा कि मैंने सत्यापित किया है। जैसे 02/29/2013 अमान्य दिनांक है। दिए गए फ़ंक्शन को वर्तमान स्वीकार्य दिनांक प्रारूपों के अनुसार दिनांक पार्स करें। यह सच है अगर तारीख को सफलतापूर्वक पारस नहीं किया जाता है।

 public final boolean validateDateFormat(final String date) {
        String[] formatStrings = {"MM/dd/yyyy"};
        boolean isInvalidFormat = false;
        Date dateObj;
        for (String formatString : formatStrings) {
            try {
                SimpleDateFormat sdf = (SimpleDateFormat) DateFormat.getDateInstance();
                sdf.applyPattern(formatString);
                sdf.setLenient(false);
                dateObj = sdf.parse(date);
                System.out.println(dateObj);
                if (date.equals(sdf.format(dateObj))) {
                    isInvalidFormat = false;
                    break;
                }
            } catch (ParseException e) {
                isInvalidFormat = true;
            }
        }
        return isInvalidFormat;
    }

Question 17

यहां मैंने बाहरी पुस्तकालयों का उपयोग करते हुए नोड पर्यावरण के लिए किया है:

Date.prototype.yyyymmdd = function() {
   var yyyy = this.getFullYear().toString();
   var mm = (this.getMonth()+1).toString(); // getMonth() is zero-based
   var dd  = this.getDate().toString();
   return zeroPad([yyyy, mm, dd].join('-'));  
};

function zeroPad(date_string) {
   var dt = date_string.split('-');
   return dt[0] + '-' + (dt[1][1]?dt[1]:"0"+dt[1][0]) + '-' + (dt[2][1]?dt[2]:"0"+dt[2][0]);
}

function isDateCorrect(in_string) {
   if (!matchesDatePattern) return false;
   in_string = zeroPad(in_string);
   try {
      var idate = new Date(in_string);
      var out_string = idate.yyyymmdd();
      return in_string == out_string;
   } catch(err) {
      return false;
   }

   function matchesDatePattern(date_string) {
      var dateFormat = /[0-9]+-[0-9]+-[0-9]+/;
      return dateFormat.test(date_string); 
   }
}

और यहाँ इसका उपयोग कैसे करना है:

isDateCorrect('2014-02-23')
true

Question 18

// to return valid days of month, according to month and year
int returnDaysofMonth(int month, int year) {
    int daysInMonth;
    boolean leapYear;
    leapYear = checkLeap(year);
    if (month == 4 || month == 6 || month == 9 || month == 11)
        daysInMonth = 30;
    else if (month == 2)
        daysInMonth = (leapYear) ? 29 : 28;
    else
        daysInMonth = 31;
    return daysInMonth;
}

// to check a year is leap or not
private boolean checkLeap(int year) {
    Calendar cal = Calendar.getInstance();
    cal.set(Calendar.YEAR, year);
    return cal.getActualMaximum(Calendar.DAY_OF_YEAR) > 365;
}

Question 19

यहाँ मैं तारीख प्रारूप की जाँच करेगा:

 public static boolean checkFormat(String dateTimeString) {
    return dateTimeString.matches("^\\d{4}-\\d{2}-\\d{2}") || dateTimeString.matches("^\\d{4}-\\d{2}-\\d{2}\\s\\d{2}:\\d{2}:\\d{2}")
            || dateTimeString.matches("^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}") || dateTimeString
            .matches("^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z") ||
            dateTimeString.matches("^\\d{4}-\\d{2}-\\d{2}\\s\\d{2}:\\d{2}:\\d{2}Z");
}

Question 20

        public static String detectDateFormat(String inputDate, String requiredFormat) {
        String tempDate = inputDate.replace("/", "").replace("-", "").replace(" ", "");
        String dateFormat;

        if (tempDate.matches("([0-12]{2})([0-31]{2})([0-9]{4})")) {
            dateFormat = "MMddyyyy";
        } else if (tempDate.matches("([0-31]{2})([0-12]{2})([0-9]{4})")) {
            dateFormat = "ddMMyyyy";
        } else if (tempDate.matches("([0-9]{4})([0-12]{2})([0-31]{2})")) {
            dateFormat = "yyyyMMdd";
        } else if (tempDate.matches("([0-9]{4})([0-31]{2})([0-12]{2})")) {
            dateFormat = "yyyyddMM";
        } else if (tempDate.matches("([0-31]{2})([a-z]{3})([0-9]{4})")) {
            dateFormat = "ddMMMyyyy";
        } else if (tempDate.matches("([a-z]{3})([0-31]{2})([0-9]{4})")) {
            dateFormat = "MMMddyyyy";
        } else if (tempDate.matches("([0-9]{4})([a-z]{3})([0-31]{2})")) {
            dateFormat = "yyyyMMMdd";
        } else if (tempDate.matches("([0-9]{4})([0-31]{2})([a-z]{3})")) {
            dateFormat = "yyyyddMMM";
        } else {
            return "Pattern Not Added";
//add your required regex
        }
        try {
            String formattedDate = new SimpleDateFormat(requiredFormat, Locale.ENGLISH).format(new SimpleDateFormat(dateFormat).parse(tempDate));

            return formattedDate;
        } catch (Exception e) {
            //
            return "";
        }

    }

Question 21

Result विरासत ’तिथि प्रारूप के साथ, हम परिणाम को प्रारूपित कर सकते हैं और स्रोत से इसकी तुलना कर सकते हैं।

    public boolean isValidFormat(String source, String pattern) {
    SimpleDateFormat sd = new SimpleDateFormat(pattern);
    sd.setLenient(false);
    try {
        Date date = sd.parse(source);
        return date != null && sd.format(date).equals(source);
    } catch (Exception e) {
        return false;
    }
}

यह क्रियान्वयन स्रोत को 'झूठा' कहता है = 01.01.04 पैटर्न '01 .01.2004 'के साथ

Question 22

यदि आप एक सख्त सत्यापन पसंद करते हैं तो झूठा

public boolean isThisDateValid(String dateToValidate, String dateFromat){

    if(dateToValidate == null){
        return false;
    }

    SimpleDateFormat sdf = new SimpleDateFormat(dateFromat);
    sdf.setLenient(false);

    try {

        //if not valid, it will throw ParseException
        Date date = sdf.parse(dateToValidate);
        System.out.println(date);

    } catch (ParseException e) {

        e.printStackTrace();
        return false;
    }

    return true;
}