item for collections kotlin

collections - for - list object kotlin



A la lista de Kotlin le faltan “agregar”, “eliminar”, falta el mapa “poner”, etc. (10)

A diferencia de muchos idiomas, Kotlin distingue entre colecciones mutables e inmutables (listas, conjuntos, mapas, etc.). El control preciso sobre exactamente cuándo se pueden editar las colecciones es útil para eliminar errores y para diseñar buenas API.

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

Deberá usar una lista 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() también debería funcionar.

En Java podríamos hacer lo siguiente

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

Pero si lo reescribimos a Kotlin directamente como se muestra a continuación

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

Recibí el error de no encontrar la función add y remove de mi lista

Trabajo para transmitirlo a ArrayList, pero es extraño tener que hacerlo, mientras que en Java no es necesario. Y eso frustra el propósito de tener la clase abstracta Lista

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

¿Hay alguna manera de usar List pero sin necesidad de lanzarlo, como lo que se podría hacer en Java?

En Kotlin tienes que usar MutableList o ArrayList .

Veamos cómo funcionan los métodos de 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) }

Veamos cómo funcionan los métodos de 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) }

Espero que esto ayude.

Definir una colección de listas en Kotlin de diferentes maneras:

  • Variable inmutable con lista inmutable (solo lectura):

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


  • Variable inmutable con lista mutable:

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

    o sin valor inicial: lista vacía y sin tipo de variable explícita:

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

    • puede agregar elementos a la lista:
      • users.add(anohterUser) o
      • users += anotherUser (bajo el capó es users.add(anohterUser) )


  • Variable mutable con lista inmutable:

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

    o sin valor inicial: lista vacía y sin tipo de variable explícita:

    var users = emptyList<User>()

    • NOTA: puede agregar * elementos a la lista:
      • users += anotherUser - * crea una nueva ArrayList y la asigna a los users


  • Variable mutable con lista mutable:

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

    o sin valor inicial: lista vacía y sin tipo de variable explícita:

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

    • NOTA: puede agregar elementos a la lista:
      • users.add(anohterUser)
      • pero sin usar users += anotherUser

        Error: Kotlin: ambigüedad de los operadores de asignación:
        public operator fun Collection.plus (element: String): Lista definida en kotlin.collections
        @InlineOnly diversión en línea del operador público MutableCollection.plusAssign (elemento: String): Unidad definida en kotlin.collections


ver también: https://kotlinlang.org/docs/reference/collections.html

Aparentemente, la lista predeterminada de Kotlin es inmutable. Para tener una Lista que pueda cambiar, uno debe usar MutableList como se muestra a continuación

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

No obstante, no se recomienda utilizar MutableList a menos que se trate de una lista que realmente desee cambiar. Consulte https://hackernoon.com/read-only-collection-in-kotlin-leads-to-better-coding-40cdfa4c6359 para ver cómo la colección de solo lectura proporciona una mejor codificación.

De acuerdo con todas las respuestas anteriores sobre el uso de MutableList, pero también puede agregar / eliminar de la Lista y obtener una nueva lista como se muestra a continuación.

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

O

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

En concepto de datos inmutables, tal vez esta sea una mejor manera:

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

Las principales respuestas aquí hablan correctamente de la diferencia en Kotlin entre la List solo lectura (NOTA: es de solo lectura, no "inmutable" ) y MutableList .

En general, uno debe esforzarse por usar listas de solo lectura, sin embargo, la mutabilidad sigue siendo útil a menudo en el momento de la construcción , especialmente cuando se trata de bibliotecas de terceros con interfaces no funcionales. Para los casos en los que las técnicas de construcción alternativas no están disponibles, como el uso de listOf directamente, o la aplicación de una construcción funcional como fold o reduce , una construcción simple de "función de constructor" como la siguiente produce muy bien una lista de solo lectura de una mutable temporal:

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

y esto se puede encapsular muy bien en una función de utilidad en línea reutilizable:

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

que se puede llamar así:

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

Ahora, toda la mutabilidad está aislada en un ámbito de bloque utilizado para la construcción de la lista de solo lectura, y el resto de su código usa la lista de solo lectura que se genera desde el generador.

Puedes hacerlo con crear uno nuevo como este.

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

Ahora puedes usar list2, gracias.

Una list es immutable de forma Default , puede usar ArrayList lugar. Me gusta esto :

val orders = arrayListOf<String>()

entonces puede add/delete elementos de esto como a continuación:

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

de forma predeterminada, ArrayList es mutable para que pueda realizar las operaciones en él.