198

जावा में हम निम्नलिखित कर सकते हैं

public class TempClass {
    List<Integer> myList = null;
    void doSomething() {
        myList = new ArrayList<>();
        myList.add(10);
        myList.remove(10);
    }
}

लेकिन अगर हम इसे कोटलिन को सीधे नीचे के रूप में लिखते हैं

class TempClass {
    var myList: List<Int>? = null
    fun doSomething() {
        myList = ArrayList<Int>()
        myList!!.add(10)
        myList!!.remove(10)
    }
}

मुझे अपनी सूची से नहीं मिल पाने addऔर removeकार्य करने की त्रुटि मिली

मैं इसे ArrayList को कास्टिंग करने के लिए काम करता हूं, लेकिन इसे कास्टिंग करने के लिए अजीब आवश्यकता है, जबकि जावा में कास्टिंग की आवश्यकता नहीं है। और वह अमूर्त वर्ग सूची होने के उद्देश्य को पराजित करता है

class TempClass {
    var myList: List<Int>? = null
    fun doSomething() {
        myList = ArrayList<Int>()
        (myList!! as ArrayList).add(10)
        (myList!! as ArrayList).remove(10)
    }
}

क्या मेरे लिए सूची का उपयोग करने का एक तरीका है, लेकिन इसे डालने की आवश्यकता नहीं है, जैसे कि जावा में क्या किया जा सकता है?

collections kotlin

— Elye
स्रोत

1

सिर्फ एक टिप्पणी कि आप ऐसा क्यों नहीं कर सकते myList = nullऔर फिर बाद में कॉल ऐड के बिना !!। आप lateinitअपनी संपत्ति के सामने कीवर्ड का उपयोग करके इसे इस तरह से दूर कर सकते हैं: lateinit var myList: List<Int>इस तरह आपको सूची को तुरंत आरंभीकृत करने की आवश्यकता नहीं होगी, लेकिन आप संकलक को गारंटी देते हैं कि आप पहली बार सूची का उपयोग करने से पहले इसे शुरू कर देंगे। यह एक अच्छा समाधान है, लेकिन यह एक डेवलपर के रूप में आप पर जिम्मेदारी डालता है।

— डारविंड

353

कई भाषाओं के विपरीत, कोटलिन परस्पर और अपरिवर्तनीय संग्रह (सूची, सेट, नक्शे, आदि) के बीच अंतर करता है। ठीक उसी समय सटीक नियंत्रण जब संग्रह को संपादित किया जा सकता है, बग को खत्म करने के लिए और अच्छे एपीआई के डिजाइन के लिए उपयोगी है।

https://kotlinlang.org/docs/reference/collections.html

आपको एक MutableListसूची का उपयोग करना होगा ।

class TempClass {
    var myList: MutableList<Int> = mutableListOf<Int>()
    fun doSomething() {
        // myList = ArrayList<Int>() // initializer is redundant
        myList.add(10)
        myList.remove(10)
    }
}

MutableList<Int> = arrayListOf() काम भी करना चाहिए।

— Fulvio
स्रोत

4

अच्छा और अच्छा लिखित उत्तर। मैं तुम्हारा जवाब देने के बावजूद मॉडल जवाब के रूप में तुम्हारा चयन कर रहा हूँ :)

— एलि

6

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

— किरिल रहमान

37

विभिन्न तरीकों से कोटलिन में सूची संग्रह को परिभाषित करना:

अपरिवर्तनीय के साथ अपरिवर्तनीय चर (केवल पढ़ने के लिए) सूची:
```
val users: List<User> = listOf( User("Tom", 32), User("John", 64) )
```
परिवर्तनशील सूची के साथ अपरिवर्तनीय चर:
```
val users: MutableList<User> = mutableListOf( User("Tom", 32), User("John", 64) )
```
या प्रारंभिक मूल्य के बिना - खाली सूची और स्पष्ट चर प्रकार के बिना:
```
val users = mutableListOf<User>()
//or
val users = ArrayList<User>()
```
- आप सूची में आइटम जोड़ सकते हैं:
  - users.add(anohterUser) या
  - users += anotherUser(यह हुड के तहत users.add(anohterUser))

अपरिवर्तनीय सूची के साथ परिवर्तनशील चर:
```
var users: List<User> = listOf( User("Tom", 32), User("John", 64) )
```
या प्रारंभिक मूल्य के बिना - खाली सूची और स्पष्ट चर प्रकार के बिना:
```
var users = emptyList<User>()
```
- नोट: आप सूची में * आइटम जोड़ सकते हैं:
  - users += anotherUser - * यह नया ArrayList बनाता है और इसे असाइन करता है users

परिवर्तनशील सूची के साथ परस्पर परिवर्तनशील:
```
var users: MutableList<User> = mutableListOf( User("Tom", 32), User("John", 64) )
```
या प्रारंभिक मूल्य के बिना - खाली सूची और स्पष्ट चर प्रकार के बिना:
```
var users = emptyList<User>().toMutableList()
//or
var users = ArrayList<User>()
```
- नोट: आप सूची में आइटम जोड़ सकते हैं:
  - users.add(anohterUser)
  - लेकिन उपयोग नहीं कर रहा है users += anotherUser
    
    त्रुटि: कोटलिन: असाइनमेंट ऑपरेटर अस्पष्टता:
    सार्वजनिक ऑपरेटर मज़ेदार Collection.plus (तत्व: स्ट्रिंग): सूची kotlin.collections में परिभाषित की गई है @
    इनलाइन ऑपरेटर इनलाइन ऑपरेटर मज़ा MutableCollection.plusAign (तत्व: स्ट्रिंग): इकाई kotlin.collections में परिभाषित

इसे भी देखें: https://kotlinlang.org/docs/reference/collections.html

— लुकास एम।
स्रोत

9

MutableList का उपयोग करने के सभी उपरोक्त उत्तरों से सहमत हैं, लेकिन आप सूची से भी जोड़ / हटा सकते हैं और नीचे के रूप में एक नई सूची प्राप्त कर सकते हैं।

val newListWithElement = existingList + listOf(element)
val newListMinusElement = existingList - listOf(element)

या

val newListWithElement = existingList.plus(element)
val newListMinusElement = existingList.minus(element)

— दिनेश साल्वे
स्रोत

8

जाहिर है, कोटलिन की डिफ़ॉल्ट सूची अपरिवर्तनीय है। एक सूची है कि बदल सकता है, एक नीचे के रूप में MutableList का उपयोग करना चाहिए

class TempClass {
    var myList: MutableList<Int>? = null
    fun doSomething() {
        myList = ArrayList<Int>()
        myList!!.add(10)
        myList!!.remove(10)
    }
}

फिर भी अद्यतन किया जाता है, यह तब तक MutableList का उपयोग करने की अनुशंसा नहीं की जाती है जब तक कि उस सूची के लिए जिसे आप वास्तव में बदलना चाहते हैं। केवल पढ़ने के लिए कैसे बेहतर संग्रह प्रदान करता है के लिए https://hackernoon.com/read-only-collection-in-kotlin-leads-to-better-coding-40cdfa4c6359 को संदर्भित करता है ।

— Elye
स्रोत

आप उपयोग करने के बारे में सही हैं MutableList, हालाँकि इसे शुरू करने से nullकाम नहीं चलेगा। केवल सुरक्षित या गैर-नल मुखर कॉल को अनुमति देने योग्य प्रकार के अशक्त रिसीवर पर अनुमति दी जाती है MutableList<Int>।

— फुलवियो

यह मेरे अंत पर काम करता है, और कोई त्रुटि नहीं मिली। जब तक मुझे इसकी आवश्यकता न हो, मुझे इसे शुरू करने की आवश्यकता नहीं हैdoSomething

— एलि

@ मुझे पता है कि यह एक पुराना उत्तर और प्रश्न है, लेकिन lateinitसूची को अशक्त बनाने के बजाय इस मुद्दे के बारे में जाने का उचित तरीका है। याद नहीं है कि क्या lateinitकोटलिन की शुरुआत से जोड़ा गया था, लेकिन यह निश्चित रूप से आजकल इसका उपयोग करने के लिए समाधान है :-)

— डारविंड

5

कोटलिन में आपको उपयोग करना है `MutableList`या `ArrayList`।

आइए देखें कि कैसे MutableListकाम के तरीके :

var listNumbers: MutableList<Int> = mutableListOf(10, 15, 20)
// Result: 10, 15, 20

listNumbers.add(1000)
// Result: 10, 15, 20, 1000

listNumbers.add(1, 250)
// Result: 10, 250, 15, 20, 1000

listNumbers.removeAt(0)
// Result: 250, 15, 20, 1000

listNumbers.remove(20)
// Result: 250, 15, 1000

for (i in listNumbers) { 
    println(i) 
}

आइए देखें कि कैसे ArrayListकाम के तरीके :

var arrayNumbers: ArrayList<Int> = arrayListOf(1, 2, 3, 4, 5)
// Result: 1, 2, 3, 4, 5

arrayNumbers.add(20)
// Result: 1, 2, 3, 4, 5, 20

arrayNumbers.remove(1)
// Result: 2, 3, 4, 5, 20

arrayNumbers.clear()
// Result: Empty

for (j in arrayNumbers) { 
    println(j) 
}

— एंडी फेडोरॉफ़
स्रोत

4

आप इस तरह से नया बना सकते हैं।

var list1 = ArrayList<Int>()
var list2  = list1.toMutableList()
list2.add(item)

अब आप list2 का उपयोग कर सकते हैं, धन्यवाद।

— दलविंदर सिंह
स्रोत

3

https://kotlinlang.org/docs/reference/collections.html

उपरोक्त लिंक के अनुसार सूची <E> कोटलिन में अपरिवर्तनीय है। हालांकि यह काम करेगा:

var list2 = ArrayList<String>()
list2.removeAt(1)

— sgrover
स्रोत

इसका मतलब है कि list2यह एक परिवर्तनशील सूची है, देखें stackoverflow.com/questions/43114367/… ।

— कूलमाइंड

2

बिल्डरों के लिए सीमित क्षमता

यहाँ शीर्ष उत्तर सही ढंग से केवल-पढ़ने के बीच कोटलिन के अंतर पर बोलते हैं List(नोट: यह केवल-पढ़ने योग्य है, "अपरिवर्तनीय" नहीं ), और MutableList।

सामान्य तौर पर, किसी को केवल-पढ़ने वाली सूचियों का उपयोग करने का प्रयास करना चाहिए, हालांकि, निर्माण के समय में परिवर्तनशीलता अभी भी अक्सर उपयोगी होती है , खासकर जब गैर-कार्यात्मक इंटरफेस के साथ तीसरे पक्ष के पुस्तकालयों से निपटना। ऐसे मामलों के लिए जिनमें वैकल्पिक निर्माण तकनीक उपलब्ध नहीं है, जैसे कि listOfसीधे उपयोग करना , या जैसे कार्यात्मक निर्माण को लागू करना foldया reduce, एक साधारण "बिल्डर फ़ंक्शन" निर्माण निम्न तरह से अस्थायी म्यूटेबल से केवल-पढ़ने के लिए सूची तैयार करता है:

val readonlyList = mutableListOf<...>().apply {
  // manipulate your list here using whatever logic you need
  // the `apply` function sets `this` to the `MutableList`
  add(foo1)
  addAll(foos)
  // etc.
}.toList()

और यह अच्छी तरह से एक पुन: प्रयोज्य इनलाइन उपयोगिता समारोह में समझाया जा सकता है:

inline fun <T> buildList(block: MutableList<T>.() -> Unit) = 
  mutableListOf<T>().apply(block).toList()

जिसे इस तरह कहा जा सकता है:

val readonlyList = buildList<String> {
  add("foo")
  add("bar")
}

अब, सभी पठनीयता को केवल-पढ़ने के लिए सूची के निर्माण के लिए उपयोग किए जाने वाले एक ब्लॉक स्कोप से अलग किया जाता है, और आपके बाकी कोड रीड-ओनली सूची का उपयोग करते हैं जो बिल्डर से आउटपुट है।

अद्यतन : Kotlin 1.3.70 के रूप में, सही buildListसमारोह से ऊपर है उपलब्ध , एक प्रयोगात्मक समारोह के रूप में मानक पुस्तकालय में अपनी analogues के साथ-साथ buildSetऔर buildMap। Https://blog.jetbrains.com/kotlin/2020/03/kotlin-1-3-70-released/ देखें ।

— रमन
स्रोत

धन्यवाद और लागू विधि के भीतर व्यापार तर्क के साथ अच्छी तरह से काम किया, यहां तक कि एक और प्रयोग किया।फोरएच {ऐड (foo)} को .appy {} के अंदर

— BENN1TH

1

अपरिवर्तनीय डेटा की अवधारणा में, शायद यह एक बेहतर तरीका है:

class TempClass {
    val list: List<Int> by lazy {
        listOf<Int>()
    }
    fun doSomething() {
        list += 10
        list -= 10
    }
}

— bbsimon
स्रोत

1

एक listहै immutableद्वारा Default, आप उपयोग कर सकते हैं ArrayListबजाय। इस तरह :

 val orders = arrayListOf<String>()

तो आप add/deleteइस तरह से नीचे से आइटम कर सकते हैं:

orders.add("Item 1")
orders.add("Item 2")

डिफ़ॉल्ट रूप ArrayListसे mutableआप इस पर परिचालन कर सकते हैं।

— बिजली
स्रोत

कोटलिन की सूची "ऐड", "रिमूव", मैप मिसिंग "पुट", आदि गायब है?

विभिन्न तरीकों से कोटलिन में सूची संग्रह को परिभाषित करना:

कोटलिन में आपको उपयोग करना है MutableListया ArrayList।

बिल्डरों के लिए सीमित क्षमता

कोटलिन में आपको उपयोग करना है `MutableList`या `ArrayList`।