web-dev-qa-db-fra.com

La liste de Kotlin manquant "ajouter", "supprimer" etc?

En Java, nous pourrions faire ce qui suit

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

Mais si nous le réécrivons dans Kotlin directement comme ci-dessous

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

J'ai eu l'erreur de ne pas trouver la fonction add et remove dans ma liste

Je travaille autour de le transformer en ArrayList, mais c'est étrange de devoir le lancer, alors qu'en Java, le casting n'est pas requis. Et cela va à l'encontre de l'objectif de la liste de classes abstraites

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

Existe-t-il un moyen pour moi d’utiliser List sans avoir besoin de le lancer, comme ce qui pourrait être fait en Java?

collectionskotlin
102
Elye

Contrairement à de nombreuses langues, Kotlin distingue les collections modifiables et immuables (listes, ensembles, cartes, etc.). Un contrôle précis sur le moment précis où les collections peuvent être modifiées est utile pour éliminer les bogues et pour concevoir de bonnes API.

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

Vous devrez utiliser une liste 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() devrait également fonctionner.

208
fuzz

Apparemment, la liste de Kotlin par défaut est immuable . Pour avoir une liste qui pourrait changer, il faut utiliser MutableList comme ci-dessous

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

Updated Néanmoins, il n'est pas recommandé d'utiliser MutableList sauf pour une liste que vous souhaitez réellement modifier. Fait référence à https://hackernoon.com/read-only-collection-in-kotlin-leads-to-better-coding-40cdfa4c6359 pour savoir comment la collecte en lecture seule permet un meilleur codage.

5
Elye

Acceptez toutes les réponses ci-dessus concernant l’utilisation de MutableList mais vous pouvez également ajouter/supprimer de la liste et obtenir une nouvelle liste comme ci-dessous.

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

Ou

val newListWithElement = existingList.plus(element)
val newListMinusElement = existingList.minus(element)
4
dinesh salve

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

Selon le lien ci-dessus, la liste <E> est immuable en Kotlin. Cependant, cela fonctionnerait:

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

list est immutable by Default, vous pouvez utiliser ArrayList à la place. comme ça :

 val orders = arrayListOf<String>()

alors vous pouvez add/delete éléments de ceci comme ci-dessous: 

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

par défaut, ArrayList est mutable afin que vous puissiez y effectuer les opérations.

1
Thunder

Dans le concept de données immuables, c'est peut-être un meilleur moyen:

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

Dans Kotlin, vous devez utiliser MutableList ou ArrayList.

Voyons comment les méthodes deMutableListwork:

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) 
}

Voyons comment les méthodes deArrayListwork:

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) 
}

J'espère que cela t'aides.

0
ARGeo

Les réponses les plus pertinentes ici indiquent correctement la différence en Kotlin entre List en lecture seule (NOTE: c'est en lecture seule, pas "immuable" ), et MutableList.

En général, il convient de s’efforcer d’utiliser des listes en lecture seule. Toutefois, la mutabilité est encore souvent utile à construction time, en particulier lorsqu’il s’agit de bibliothèques tierces avec des interfaces non fonctionnelles. Dans les cas où il n’existe pas de techniques de construction alternatives, telles que l’utilisation directe de listOf ou l’application d’une construction fonctionnelle telle que fold ou reduce, une construction simple "fonction de générateur" comme celle-ci génère une liste en lecture seule à partir d’une structure temporaire modifiable:

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()

et ceci peut être bien encapsulé dans une fonction utilitaire en ligne réutilisable:

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

qui peut s'appeler comme ça:

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

Désormais, toute la mutabilité est isolée dans une portée de bloc utilisée pour la construction de la liste en lecture seule, et le reste de votre code utilise la liste en lecture seule générée par le générateur.

0
Raman

Vous pouvez faire avec en créer un nouveau comme celui-ci.

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

Maintenant vous pouvez utiliser list2, merci.

0
Dalvinder Singh