ArrayList<String> को String[] में बदलना: शुरुआती की 5 घातक गलतियाँ

ArrayList<String> से String[]: खुद को धोखा न दें

नमस्ते दोस्त! यदि आप यह पढ़ रहे हैं, तो इसका मतलब है कि आप पहले से ही एक क्लासिक समस्या का सामना कर चुके हैं — ArrayList<String> को एक सामान्य String[] ऐरे में बदलना। लगता है, इसमें क्या गलत हो सकता है? आप toArray() विधि लेते हैं, इसे कॉल करते हैं — और काम हो जाता है। लेकिन ऐसा नहीं है! Java एक धोखेबाज भाषा है, और यहाँ तक कि इतना सरल ऑपरेशन भी सिरदर्द बन सकता है यदि आप छिपे हुए खतरों को नहीं जानते।

Stack Overflow पर इस प्रश्न को हज़ारों बार देखा गया है, और यह व्यर्थ नहीं है। हमने शीर्ष 5 गलतियाँ एकत्र की हैं, जो अनुभवी डेवलपर्स भी करते हैं, और दिखाएंगे कि उनसे कैसे बचा जाए। चलिए शुरू करते हैं!

क्यों सिर्फ list.toArray() काम नहीं करता?

चलिए सीधे मुद्दे पर आते हैं। आपके पास एक सूची है:

ArrayList<String> list = new ArrayList<>();\nlist.add("Java");\nlist.add("Python");\nlist.add("C++");

आप स्ट्रिंग्स का एक ऐरे प्राप्त करना चाहते हैं। पहला विचार — list.toArray() को कॉल करना। देखिए क्या होता है:

Object[] objectArray = list.toArray(); // काम करता है, लेकिन Object[] लौटाता है\n// String[] stringArray = list.toArray(); // कंपाइलेशन त्रुटि!

गलती नंबर 1: टाइप कास्टिंग के बारे में भूलना। बिना तर्कों के toArray() विधि Object[] लौटाती है, String[] नहीं। कंपाइलर आपको आसानी से Object[] को String[] प्रकार के वेरिएबल में असाइन नहीं करने देगा। स्पष्ट कास्टिंग की आवश्यकता है:

String[] stringArray = (String[]) list.toArray(); // रनटाइम पर ClassCastException!

यहाँ से सबसे दिलचस्प शुरू होता है। दूसरी गलती — यह सोचना कि टाइप कास्टिंग बचाएगी। आपको ClassCastException मिलेगा, क्योंकि toArray() के अंदर Object[] प्रकार का ऐरे बनता है, String[] नहीं। कास्टिंग ऑब्जेक्ट के प्रकार को नहीं बदलती — यह केवल कंपाइलर से कहती है: "मुझ पर विश्वास करो, यह एक स्ट्रिंग है।" और Java रनटाइम पर जाँच करता है और अपवाद फेंकता है।

सही तरीका: toArray(new String[0])

सबसे सामान्य और सही तरीका — toArray() में सही प्रकार का एक खाली ऐरे पास करना है:

String[] stringArray = list.toArray(new String[0]);

यह क्यों काम करता है? क्योंकि toArray(T[] a) विधि एक जेनेरिक विधि है। यह T प्रकार का एक ऐरे स्वीकार करती है और उसी प्रकार का ऐरे लौटाती है। यदि पास किया गया ऐरे पर्याप्त बड़ा नहीं है, तो विधि रिफ्लेक्शन का उपयोग करके सही प्रकार का एक नया ऐरे बनाती है। यदि आकार उपयुक्त है — तो इसे भर देती है।

गलती नंबर 3: गलत आकार का ऐरे पास करना। कुछ शुरुआती लिखते हैं:

String[] stringArray = list.toArray(new String[list.size()]);

यह भी काम करता है, लेकिन आइए समझें कि क्या बेहतर है। जब हम list.size() आकार का ऐरे पास करते हैं, तो विधि इसे भरती है और लौटाती है। यदि हम new String[0] पास करते हैं — तो एक नया ऐरे बनता है। लगता है, नया ऐरे बनाने में समय क्यों बर्बाद करें? वास्तव में, JVM खाली ऐरे के निर्माण को अनुकूलित करता है, और अधिकांश मामलों में new String[0] new String[list.size()] से तेज़ काम करता है। क्यों? क्योंकि दूसरे मामले में, ऐरे बनाया जाता है, फिर null-मानों से भरा जाता है, और फिर ओवरराइट किया जाता है। अतिरिक्त काम।

आधुनिक JVM (Java 8+) अक्सर new String[0] को एक स्थिरांक में अनुकूलित करते हैं, और यह तेज़ हो जाता है। लेकिन यदि आप Java 6 या 7 के साथ काम कर रहे हैं — तो अंतर ध्यान देने योग्य हो सकता है। किसी भी स्थिति में, सबसे अच्छा अभ्यास new String[0] का उपयोग करना है, जब तक कि अत्यधिक उच्च प्रदर्शन की आवश्यकता न हो। गति-महत्वपूर्ण कोड खंडों के लिए — दोनों विकल्पों का परीक्षण करें।

छिपा हुआ खतरा: सिंक्रनाइज़ेशन और मल्टीथ्रेडिंग

गलती नंबर 4: सिंक्रनाइज़ेशन के बिना मल्टीथ्रेडेड वातावरण में रूपांतरण। कल्पना करें: आपके पास एक ArrayL