Kotlin Array को Java varargs में कैसे पास करें: शुरुआती लोगों के लिए पूरी गाइड

Kotlin Array को Java varargs में: संगतता कैसे न तोड़ें और साफ कोड कैसे लिखें

क्या आपने कभी Kotlin में कोड लिखा है, कोई पुराना Java-मेथड varargs के साथ कॉल किया है — और अचानक कंपाइलेशन एरर मिली है? अगर हाँ, तो आप अकेले नहीं हैं। Stack Overflow पर "Convert Kotlin Array to Java varargs" सवाल ने हज़ारों व्यूज़ बटोरे हैं। और यह आश्चर्यजनक नहीं है: दो भाषाओं के मिलन पर अक्सर गैर-स्पष्ट बारीकियाँ उत्पन्न होती हैं।

इस लेख में, हम समझेंगे कि Kotlin Array को वेरिएबल आर्गुमेंट्स वाले Java-मेथड में सही तरीके से कैसे पास किया जाए। आप जानेंगे कि spread-ऑपरेटर क्या है, क्यों Array<String> String... के बराबर नहीं है, और सामान्य गलतियों से कैसे बचा जाए। चलिए शुरू करते हैं!

Java में varargs क्या है और इसकी आवश्यकता क्यों है

पहले बुनियादी बातों को याद कर लेते हैं। Varargs (variable-length arguments) Java का एक तंत्र है जो किसी मेथड में एक ही प्रकार के मनमानी संख्या में आर्गुमेंट पास करने की अनुमति देता है। सिंटैक्स के रूप में, इसे टाइप के बाद तीन बिंदुओं से दर्शाया जाता है:

public void printMessages(String... messages) {\n    for (String msg : messages) {\n        System.out.println(msg);\n    }\n}

आप इस मेथड को इस तरह कॉल कर सकते हैं:

printMessages("Hello");\nprintMessages("Hello", "World");\nprintMessages(); // खाली कॉल भी काम करता है

मेथड के अंदर, आर्गुमेंट्स को String[] ऐरे के रूप में प्रस्तुत किया जाता है। लेकिन बाहर से — यह केवल अल्पविराम से अलग किए गए मानों का एक सेट है। सुविधाजनक है, है ना?

अब कल्पना करें कि आपके पास एक Kotlin Array है, और आप इसे ऐसे Java-मेथड में पास करना चाहते हैं। सीधा कोड काम नहीं करेगा:

val messages = arrayOf("Hello", "World")\nprintMessages(messages) // कंपाइलेशन एरर!

क्यों? क्योंकि Kotlin टाइप्स के मामले में अधिक सख्त है। Java-मेथड String... की अपेक्षा करता है, जबकि आप Array<String> पास कर रहे हैं। ये अलग चीजें हैं। कंपाइलर असंगति देखता है और एरर देता है।

समाधान: spread-ऑपरेटर (* ऑपरेटर)

ऐसे मामलों के लिए Kotlin में spread-ऑपरेटर मौजूद है — ऐरे के सामने एक तारांकन *। यह सचमुच ऐरे को अलग-अलग तत्वों में "खोल" देता है, जो फिर varargs के रूप में पास हो जाते हैं।

val messages = arrayOf("Hello", "World")\nprintMessages(*messages) // काम करता है!

सब कुछ सरल है। लेकिन आइए समझें कि यह अंदरूनी रूप से कैसे काम करता है।

spread-ऑपरेटर टाइप्स को कैसे बदलता है

जब आप *messages लिखते हैं, Kotlin:

\n
• ऐरे के प्रत्येक तत्व को लेता है
\n
• उन्हें Array रैपर से "बाहर निकालता" है
\n
• Java-मेथड में अलग-अलग आर्गुमेंट के रूप में पास करता है
\n

Java-मेथड के लिए, यह ऐसा दिखता है जैसे आपने printMessages("Hello", "World") लिखा हो। कोई ऐरे नहीं — केवल सीधे स्ट्रिंग्स।

एक महत्वपूर्ण बारीकी: spread-ऑपरेटर केवल Array (और toTypedArray() के माध्यम से कुछ अन्य कलेक्शन) के साथ काम करता है। सामान्य List को इस तरह नहीं खोला जा सकता।

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

spread-ऑपरेटर के बारे में जानने के बाद भी, शुरुआती अक्सर गलतियाँ करते हैं। यहाँ सबसे आम गलतियाँ हैं।

गलती 1: तारांकन के बिना ऐरे पास करना

// गलत:\nval numbers = intArrayOf(1, 2, 3)\nsomeJavaMethod(numbers) // एरर\n\n// सही:\nsomeJavaMethod(*numbers.toTypedArray())

ध्यान दें: प्रिमिटिव टाइप (IntArray, DoubleArray आदि) के लिए पहले .toTypedArray() के माध्यम से Array में बदलना आवश्यक है। spread-ऑपरेटर केवल ऑब्जेक्ट ऐरे के साथ काम करता है।

गलती 2: List के साथ भ्रम

कई लोग सीधे List<String> पास करने का प्रयास करते हैं:

val list = listOf("A", "B")\nprintMessages(*list) // एरर! List != Array

समाधान: पहले लिस्ट को ऐरे में बदलें:

printMessages(*list.toTypedAr