collections - vale - porque usar kotlin




Lista de Kotlin faltando "adicionar", "remover" etc? (7)

Ao contrário de muitas linguagens, o Kotlin distingue entre coleções mutáveis ​​e imutáveis ​​(listas, conjuntos, mapas, etc.). O controle preciso sobre quando as coleções podem ser editadas é útil para eliminar bugs e para projetar boas APIs.

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

Você precisará usar uma 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() também deve funcionar.

Em Java, podemos fazer o seguinte

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

Mas se nós reescrevemos isso para Kotlin diretamente como abaixo

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

Eu tenho o erro de não encontrar add e remove função da minha lista

Eu trabalho em torno de lançá-lo para ArrayList, mas isso é estranho precisar lançá-lo, enquanto no Casting Java não é necessário. E isso anula o propósito de ter a lista de classes abstratas

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

Existe uma maneira de eu usar a Lista, mas não precisar lançá-la, como o que poderia ser feito em Java?


Em Kotlin você tem que usar MutableList ou ArrayList .

Vamos ver como funcionam os métodos do 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) 
}

Vamos ver como funcionam os métodos do 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 isto ajude.


Aparentemente, a lista padrão de Kotlin é imutável. Para ter uma lista que poderia mudar, deve-se usar MutableList como abaixo

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

Atualizado Não obstante, não é recomendado usar o MutableList, a menos que seja uma lista que você realmente deseja alterar. Refere-se a https://hackernoon.com/read-only-collection-in-kotlin-leads-to-better-coding-40cdfa4c6359 para saber como a coleção somente leitura fornece melhor codificação.


As respostas principais aqui falam corretamente sobre a diferença no Kotlin entre a List somente de leitura (NOTA: é somente leitura, não "imutável" ) e MutableList .

Em geral, um deve se esforçar para usar listas somente leitura, no entanto, a mutabilidade ainda é frequentemente útil em tempo de construção , especialmente quando se lida com bibliotecas de terceiros com interfaces não funcionais. Para casos em que técnicas de construção alternativas não estão disponíveis, como usar diretamente listOf ou aplicar uma construção funcional como fold ou reduce , uma construção simples de "builder function" como a seguinte produz uma lista somente leitura de uma mutável temporária:

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

e isso pode ser bem encapsulado em uma função de utilidade in-line reutilizável:

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

que pode ser chamado assim:

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

Agora, toda a mutabilidade é isolada para um escopo de bloco usado para construção da lista somente leitura, e o restante do seu código usa a lista somente leitura que é gerada pelo construtor.


No conceito de dados imutáveis, talvez seja uma maneira melhor:

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

Uma list é immutable por Default , você pode usar ArrayList vez disso. como isso :

 val orders = arrayListOf<String>()

então você pode add/delete itens como abaixo:

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

por padrão ArrayList é mutable para que você possa executar as operações nele.








kotlin