मास्टर जावा दिनांक फ़ॉर्मेटिंग:SimpleDateFormat और DateFormat की व्याख्या

परिचय

मुख्य बातें

• DateFormat सार स्वरूपण एपीआई है, और SimpleDateFormat पैटर्न-आधारित फ़ॉर्मेटिंग और पार्सिंग के लिए ठोस कार्यान्वयन है
• SimpleDateFormat वर्षों, महीनों, दिनों, समय क्षेत्रों और समयक्षेत्र आउटपुट के लिए समृद्ध पैटर्न टोकन का समर्थन करता है
• एक साझा SimpleDateFormat मल्टीथ्रेडेड कोड में इंस्टेंस असुरक्षित है क्योंकि इसकी आंतरिक स्थिति परिवर्तनशील है
• ThreadLocal<SimpleDateFormat> जब लीगेसी कोड तुरंत माइग्रेट नहीं हो सकता है तो प्रति थ्रेड फ़ॉर्मेटर इंस्टेंस को अलग करता है
• DateTimeFormatter अपरिवर्तनीय और थ्रेड-सुरक्षित है, इसलिए यह नए जावा कोड के लिए पसंदीदा प्रतिस्थापन है
• .parse() ParseException फेंक सकते हैं , इसलिए पार्सिंग कोड को ट्राई-कैच और उपयोगी त्रुटि संदेशों का उपयोग करना चाहिए
• setLenient(false) 2024-13-45 जैसी अमान्य तिथियों को चुपचाप समायोजित होने से रोकता है
• हमेशा एक स्पष्ट Locale पास करें सर्वर परिनियोजन में पर्यावरण-निर्भर आउटपुट से बचने के लिए

Java में SimpleDateFormat क्या है?

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
Locale locale = Locale.US;
DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.MEDIUM, locale);
String styleBased = dateFormat.format(new Date());
SimpleDateFormat patternBased = new SimpleDateFormat("dd-MM-yyyy HH:mm:ss", locale);
String patternOutput = patternBased.format(new Date());
System.out.println(styleBased);
System.out.println(patternOutput);

Jan 5, 2026
05-01-2026 14:30:22

Locale locale = new Locale.Builder()
 .setLanguage("en")
 .setRegion("US")
 .build();

Locale locale = Locale.US;
DateFormat timeFormat = DateFormat.getTimeInstance(DateFormat.MEDIUM, locale);
System.out.println(timeFormat.format(new Date()));

Output depends on the current time and timezone, for example:
2:30:45 PM

SimpleDateFormat पैटर्न सिंटैक्स संदर्भ

पैटर्न दोहराव और आउटपुट चौड़ाई

अपेक्षित आउटपुट के साथ सामान्य पैटर्न के उदाहरण

SimpleDateFormat का उपयोग करके दिनांक को कैसे प्रारूपित करें

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
Date now = new Date();
SimpleDateFormat basic = new SimpleDateFormat("MM-dd-yyyy", Locale.US);
SimpleDateFormat withTime = new SimpleDateFormat("dd-MM-yyyy HH:mm:ss", Locale.US);
SimpleDateFormat isoLike = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ", Locale.US);
System.out.println(basic.format(now));
System.out.println(withTime.format(now));
System.out.println(isoLike.format(now));

01-05-2026
05-01-2026 14:30:45
2026-01-05T14:30:45+0000

SimpleDateFormat का उपयोग करके किसी स्ट्रिंग को दिनांक तक कैसे पार्स करें

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
try {
 SimpleDateFormat dateParser = new SimpleDateFormat("dd-MM-yyyy", Locale.US);
 Date parsedDate = dateParser.parse("05-01-2026");
 System.out.println(parsedDate);
 SimpleDateFormat timeParser = new SimpleDateFormat("HH:mm:ss", Locale.US);
 Date parsedTime = timeParser.parse("22:15:09");
 System.out.println(parsedTime);
} catch (ParseException e) {
 e.printStackTrace();
}

Mon Jan 05 00:00:00 UTC 2026
Thu Jan 01 22:15:09 UTC 1970

ParseException को सही ढंग से संभालना

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Locale;
String input = "31/01/2026";
String pattern = "dd-MM-yyyy";
SimpleDateFormat parser = new SimpleDateFormat(pattern, Locale.US);
try {
 parser.parse(input);
 System.out.println("Parsed successfully");
} catch (ParseException e) {
 // Include both the input value and pattern for easier debugging.
 System.err.println("Failed to parse date string: " + input);
 System.err.println("Expected pattern: " + pattern);
 System.err.println("Parser error: " + e.getMessage());
}

Failed to parse date string: 31/01/2026
Expected pattern: dd-MM-yyyy
Parser error: Unparseable date: "31/01/2026"

विश्लेषण से पहले दिनांक स्ट्रिंग को मान्य करना

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Locale;
String invalid = "2024-13-45";
SimpleDateFormat lenientParser = new SimpleDateFormat("yyyy-MM-dd", Locale.US);
SimpleDateFormat strictParser = new SimpleDateFormat("yyyy-MM-dd", Locale.US);
strictParser.setLenient(false);
System.out.println("Lenient parse result:");
try {
 // Lenient mode silently rolls over invalid values instead of throwing.
 System.out.println(lenientParser.parse(invalid));
} catch (ParseException e) {
 System.out.println("ParseException: " + e.getMessage());
}
System.out.println("Strict parse result:");
try {
 System.out.println(strictParser.parse(invalid));
} catch (ParseException e) {
 System.out.println("ParseException: " + e.getMessage());
}

Lenient parse result:
Fri Feb 14 00:00:00 UTC 2025
Strict parse result:
ParseException: Unparseable date: "2024-13-45"

SimpleDateFormat में टाइमज़ोन प्रबंधन

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.TimeZone;
Date timestamp = new Date(1700000000000L); // Fixed instant for repeatable output
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss Z", Locale.US);
formatter.setTimeZone(TimeZone.getTimeZone("UTC"));
System.out.println("UTC: " + formatter.format(timestamp));
formatter.setTimeZone(TimeZone.getTimeZone("America/New_York"));
System.out.println("New York: " + formatter.format(timestamp));
formatter.setTimeZone(TimeZone.getTimeZone("Asia/Kolkata"));
System.out.println("Kolkata: " + formatter.format(timestamp));

UTC: 2023-11-14 22:13:20 +0000
New York: 2023-11-14 17:13:20 -0500
Kolkata: 2023-11-15 03:43:20 +0530

सामान्य समयक्षेत्र गलतियाँ और उनसे कैसे बचें

• Date UTC मिलीसेकंड को संग्रहीत करता है, और टाइमज़ोन केवल फ़ॉर्मेट करते समय लागू होता है
• कॉलिंग setTimeZone() मल्टीथ्रेडेडएनवायरमेंट में एक साझा फ़ॉर्मेटर इंस्टेंस पर किसी अन्य थ्रेड के इन-फ़्लाइट कॉल के लिए टाइमज़ोन मध्य-ऑपरेशन को बदल सकता है, बिना किसी अपवाद के गलत टाइमज़ोन में आउटपुट उत्पन्न कर सकता है
• एकल SimpleDateFormat का पुन:उपयोग करना एसर्वलेट या स्प्रिंग कंट्रोलर में HTTP अनुरोधों का उदाहरण एक अनुरोध के setTimeZone() का कारण बन सकता है किसी अन्य अनुरोध के आउटपुट को प्रभावित करने के लिए कॉल करें; प्रति अनुरोध एक नया उदाहरण बनाएं या ThreadLocal<SimpleDateFormat> का उपयोग करें राज्य को अलग करना
• TimeZone.getTimeZone("Invalid/Zone") चुपचाप GMT पर वापस आ जाता है क्योंकि विधि अनुबंध अपवाद को फेंकने के बजाय गैर-मान्यता प्राप्त आईडी के लिए GMT को डिफ़ॉल्ट के रूप में निर्दिष्ट करता है
• ज़ोन आईडी को ZoneId.of() से मान्य करें java.time से उन्हें TimeZone.getTimeZone() पर भेजने से पहले; ZoneId.of() ZoneRulesException फेंकता है एक अमान्य आईडी पर, जो समस्या को स्पष्ट करता है

स्थानीय-जागरूक दिनांक स्वरूपण

SimpleDateFormat कंस्ट्रक्टर में लोकेल निर्दिष्ट करना

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
Date sample = new Date(1700000000000L);
String pattern = "EEEE, dd MMMM yyyy";
SimpleDateFormat usFormatter = new SimpleDateFormat(pattern, Locale.US);
SimpleDateFormat frFormatter = new SimpleDateFormat(pattern, Locale.FRENCH);
String usDate = usFormatter.format(sample);
String frDate = frFormatter.format(sample);
System.out.println("US: " + usDate);
System.out.println("French: " + frDate);

US: Tuesday, 14 November 2023
French: mardi, 14 novembre 2023

क्षेत्र के अनुसार महीने और दिन के नामों का प्रारूपण

SimpleDateFormat के साथ थ्रेड सुरक्षा समस्याएं

SimpleDateFormat थ्रेड-सुरक्षित क्यों नहीं है

SimpleDateFormat उदाहरणों को अलग करने के लिए ThreadLocal का उपयोग करना

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
public class ThreadSafeLegacyFormatter {
 // Each thread gets one dedicated formatter instance.
 private static final ThreadLocal<SimpleDateFormat> FORMATTER =
 ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.US));
 public static String format(Date date) {
 try {
 // No cross-thread mutation because each thread reads its own formatter.
 return FORMATTER.get().format(date);
 } finally {
 // Remove the instance after use to prevent memory leaks in thread pools.
 FORMATTER.remove();
 }
 }
}

थ्रेड-सुरक्षित विकल्प के रूप में DateTimeFormatter पर स्विच करना

import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.Locale;
// Not thread-safe when shared across threads
SimpleDateFormat unsafe = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.US);
System.out.println(unsafe.format(new Date()));
// Thread-safe: DateTimeFormatter is immutable and can be stored as a static field
DateTimeFormatter safe = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss", Locale.US);
System.out.println(safe.format(LocalDateTime.now()));

2026-01-05 14:30:22
2026-01-05 14:30:22

SimpleDateFormat से DateTimeFormatter पर माइग्रेट करना

साथ-साथ कोड तुलना

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.Locale;
String pattern = "yyyy-MM-dd";
String input = "2026-01-05";
// SimpleDateFormat (legacy java.util.Date API)
SimpleDateFormat legacyFormatter = new SimpleDateFormat(pattern, Locale.US);
Date legacyParsed = legacyFormatter.parse(input);
String legacyFormatted = legacyFormatter.format(new Date());
// DateTimeFormatter (modern java.time API)
DateTimeFormatter modernFormatter = DateTimeFormatter.ofPattern(pattern, Locale.US);
LocalDate modernParsed = LocalDate.parse(input, modernFormatter);
String modernFormatted = modernFormatter.format(LocalDate.now());
System.out.println(legacyParsed);
System.out.println(legacyFormatted);
System.out.println(modernParsed);
System.out.println(modernFormatted);

Mon Jan 05 00:00:00 UTC 2026
2026-01-05
2026-01-05
2026-01-05

दो एपीआई के बीच पैटर्न सिंटैक्स अंतर

चरण-दर-चरण माइग्रेशन चेकलिस्ट

1. बदलें import java.text.SimpleDateFormat; import java.time.format.DateTimeFormatter; के साथ
2. बदलें new SimpleDateFormat("yyyy-MM-dd") DateTimeFormatter.ofPattern("yyyy-MM-dd") के साथ
3. बदलें .parse() LocalDate.parse() के साथ या LocalDateTime.parse() इनपुट परिशुद्धता
के आधार पर
4. बदलें .format(date) formatter.format(localDate) के साथ या formatter.format(localDateTime)
5. निकालें new Date() जहां संभव हो और LocalDate.now() का उपयोग करें या Instant.now()

अक्सर पूछे जाने वाले प्रश्न

Java में SimpleDateFormat और DateFormat के बीच क्या अंतर है?

क्या SimpleDateFormat थ्रेड-सुरक्षित है?

मैं SimpleDateFormat का उपयोग करके dd-MM-yyyy प्रारूप में दिनांक स्ट्रिंग को कैसे पार्स कर सकता हूं?

मैं SimpleDateFormat का उपयोग करके किसी दिनांक को भिन्न समयक्षेत्र में कैसे परिवर्तित करूं?

"yyyy-MM-dd'T'HH:mm:ssZ" पैटर्न क्या उत्पन्न करता है?

मैं SimpleDateFormat से DateTimeFormatter पर कैसे स्थानांतरित करूं?

SimpleDateFormat बिना किसी अपवाद के अमान्य दिनांक को पार्स क्यों करता है?

मैं SimpleDateFormat का उपयोग करके किसी विशिष्ट स्थान के साथ दिनांक को कैसे प्रारूपित करूं?

निष्कर्ष

• SimpleDateFormat API दस्तावेज़
• DateFormat API Doc
• DateTimeFormatter API दस्तावेज़