Kotlin में List और Array प्रकारों में अंतर

परिचय

Kotlin में `List` और `Array` दोनों क्रमिक संग्रह हैं, लेकिन उनके व्यवहार, API और उपयोग के मामलों में महत्वपूर्ण अंतर हैं।

तुलना तालिका

उदाहरण: घोषणा और उपयोग

fun main() {
    // Array - निश्चित आकार, परिवर्तनीय तत्व
    val array = arrayOf(1, 2, 3)
    println("Array: ${array.joinToString()}")
    array[0] = 10  // तत्व बदलना OK
    // array.add(4)  // कंपाइल त्रुटि - कोई add मेथड नहीं
    
    // List - अपरिवर्तनीय
    val immutableList = listOf("stud1", "stud2", "stud3")
    println("List: ${immutableList.joinToString()}")
    // immutableList[0] = "new"  // कंपाइल त्रुटि - val प्रॉपर्टी
    // immutableList.add("stud4")  // कंपाइल त्रुटि - कोई add नहीं
    
    // MutableList - डायनामिक आकार
    val mutableList = mutableListOf("Mon", "Tue", "Wed")
    mutableList.add("Thu")
    mutableList.remove("Tue")
    println("MutableList: ${mutableList.joinToString(", ")}")
}

आउटपुट

Array: 1, 2, 3
List: stud1, stud2, stud3
MutableList: Mon, Wed, Thu

प्रिमिटिव Arrays (प्रदर्शन के लिए महत्वपूर्ण)

fun main() {
    // बॉक्स्ड Array - अधिक मेमोरी, धीमा
    val boxedArray = arrayOf(1, 2, 3)  // Array = Array
    
    // अनबॉक्स्ड IntArray - प्रिमिटिव int[], तेज, कम मेमोरी
    val primitiveArray = intArrayOf(1, 2, 3)
    val doubleArray = doubleArrayOf(1.1, 2.2)
    val booleanArray = booleanArrayOf(true, false)
    
    println("प्रिमिटिव Array क्लास: ${primitiveArray.javaClass}")  // class [I
    println("बॉक्स्ड Array क्लास: ${boxedArray.javaClass}")        // class [Ljava.lang.Integer;
}

रूपांतरण

fun main() {
    val list = listOf(1, 2, 3)
    val array = arrayOf(1, 2, 3)
    
    // List → Array
    val toArray = list.toTypedArray()        // Array
    val toPrimitiveArray = list.toIntArray() // IntArray
    
    // Array → List
    val toList = array.asList()              // List (बैकिंग Array)
    val toMutableList = array.toMutableList() // MutableList (कॉपी)
    
    // प्रिमिटिव Array → List
    val primitiveArray = intArrayOf(1, 2, 3)
    val listFromPrimitive = primitiveArray.asList()  // List (बॉक्सिंग होती है)
}

कब क्या उपयोग करें?

• Array / IntArray: निश्चित आकार, उच्च प्रदर्शन, जावा इंटरऑप, निम्न-स्तरीय ऑपरेशंस
• List: अपरिवर्तनीय डेटा, फंक्शनल ट्रांसफॉर्मेशन, पठनीयता
• MutableList: डायनामिक संग्रह, जोड़/हटाने की आवश्यकता
• Sequence: बड़े/अनंत संग्रह के लिए लेज़ी मूल्यांकन

सर्वोत्तम अभ्यास

1. डिफ़ॉल्ट रूप से `List`/`MutableList` पसंद करें (समृद्ध API)
2. प्रदर्शन-महत्वपूर्ण संख्यात्मक कोड के लिए प्रिमिटिव Arrays (`IntArray`, `DoubleArray`) उपयोग करें
3. जावा इंटरऑप के लिए `Array`/`toTypedArray()`
4. `arrayOf()` के बजाय `intArrayOf()` आदि उपयोग करें जब प्रिमिटिव हों