Il manque "add" et "remove" à List de Kotlin, "put" à Map, etc ?

Question

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 directement en Kotlin 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 add y remove de ma liste

Je contourne le casting en ArrayList, mais c'est bizarre d'avoir à le faire, alors qu'en Java le casting n'est pas nécessaire. Et cela va à l'encontre de l'objectif de la classe abstraite List.

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 d'utiliser une liste sans avoir à la couler, comme cela pourrait être fait en Java ?

Answer 1

Contrairement à de nombreux langages, Kotlin fait la distinction entre les collections mutables et immuables (listes, ensembles, cartes, etc.). Un contrôle précis du moment exact 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 un MutableList liste.

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.

Answer 2

Définir une collection de listes en Kotlin de différentes manières :

• Variable immuable avec liste immuable (en lecture seule) :

  val users: List<User> = listOf( User("Tom", 32), User("John", 64) )

• Variable immuable avec liste mutable :

  val users: MutableList<User> = mutableListOf( User("Tom", 32), User("John", 64) )

  ou sans valeur initiale - liste vide et sans type de variable explicite :

  val users = mutableListOf<User>()
  //or
  val users = ArrayList<User>()

  • vous pouvez ajouter des éléments à la liste :
    • users.add(anohterUser) o
    • users += anotherUser (sous le capot, c'est users.add(anohterUser) )

• Variable mutable avec liste immuable :

  var users: List<User> = listOf( User("Tom", 32), User("John", 64) )

  ou sans valeur initiale - liste vide et sans type de variable explicite :

  var users = emptyList<User>()

  • REMARQUE : vous pouvez ajouter* des éléments à la liste :
    • users += anotherUser - *il crée une nouvelle ArrayList et l'assigne à users

• Variable mutable avec liste mutable :

  var users: MutableList<User> = mutableListOf( User("Tom", 32), User("John", 64) )

  ou sans valeur initiale - liste vide et sans type de variable explicite :

  var users = emptyList<User>().toMutableList()
  //or
  var users = ArrayList<User>()

  • NOTE : vous pouvez ajouter des éléments à la liste :

    • users.add(anohterUser)

    • mais sans utiliser users += anotherUser

      Erreur : Kotlin : Ambiguïté des opérateurs d'assignation :
      public fun opérateur Collection.plus(element : String) : Liste définie dans kotlin.collections
      @InlineOnly public inline operator fun MutableCollection.plusAssign(element : String) : Unité définie dans kotlin.collections

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

Answer 3

Je suis d'accord avec toutes les réponses ci-dessus concernant l'utilisation de MutableList, mais vous pouvez également ajouter/supprimer des éléments de la liste et obtenir une nouvelle liste comme ci-dessous.

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

O

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

Answer 4

Apparemment, la liste par défaut de Kotlin est immuable. Pour avoir une liste qui peut 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)
    }
}

Mise à jour de Néanmoins, il n'est pas recommandé d'utiliser MutableList, sauf pour une liste que l'on souhaite vraiment modifier. Se réfère à 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.

Answer 5

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

Selon le lien ci-dessus, List<E> est immuable en Kotlin. Cependant, ceci pourrait fonctionner :

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