CODEWITHSUNDEEP
kotlin
Edwin Dalorzo
Edwin Dalorzo

Reputation: 78579

How to turn a Mutable Collection into an Immutable one

I was writing a small piece of code in which I internally handle my data in a mutable map, which in turn has mutable lists.

I wanted to expose my data to the API user, but to avoid any unsafe publication of my data I wanted to expose it in immutable collections even when internally being handled by mutable ones.

class School {

    val roster: MutableMap<Int, MutableList<String>> = mutableMapOf<Int, MutableList<String>>()

    fun add(name: String, grade: Int): Unit {
        val students = roster.getOrPut(grade) { mutableListOf() }
        if (!students.contains(name)) {
            students.add(name)
        }
    }

    fun sort(): Map<Int, List<String>> {
        return db().mapValues { entry -> entry.value.sorted() }
                .toSortedMap()
    }

    fun grade(grade: Int) = db().getOrElse(grade, { listOf() })
    fun db(): Map<Int, List<String>> = roster //Uh oh!
}

I managed to expose only Map and List (which are immutable) in the public API of my class, but the instances I am actually exposing are still inherently mutable.

Which means an API user could simply cast my returned map as an ImmutableMap and gain access to the precious private data internal to my class, which was intended to be protected of this kind of access.

I couldn't find a copy constructor in the collection factory methods mutableMapOf() or mutableListOf() and so I was wondering what is the best and most efficient way to turn a mutable collection into an immutable one.

Any advice or recommendations?

Upvotes: 64

Views: 51785

Answers (8)

Benny
Benny

Reputation: 2331

Use Java Collections to converts a mutable list to an immutable list:

Creating a mutable list:

val mutableList = mutableListOf<String>()

Converting into an immutable (or unmodifiable) list:

val immutableList = Collections.unmodifiableList(mutableList)

More details as indicated by the JavaDoc.

Upvotes: 27

Alireza Barakati
Alireza Barakati

Reputation: 1074

Use simple bellow codes to convert Mutable Collections into an Immutable one:

val mutableList = mutableListOf<String>()

val immutableList: List<String> = mutableList

Upvotes: -2

tony
tony

Reputation: 1

If you need to convert MutableMap<String, Any> strictly to ImmutableMap<String, Any>, this will not work

val iMap : ImmutableMap<String, Any> = mutMap.toMap() // error

I have found the only working way:

val iMap : ImmutableMap<String, Any> =  ImmutableMap.builder<String, Any>().putAll(mutMap).build()

Upvotes: 0

Renann
Renann

Reputation: 608

Simply call toMap() on your MutableMap.

val myMap = mutableMapOf<String, String>("x" to "y").toMap()

Done.

The same also works for lists.

Upvotes: 14

voddan
voddan

Reputation: 33749

A classic solution is to copy your data, so that even if modified, the change would not affect the private class property:

class School {
    private val roster = mutableMapOf<Int, MutableList<String>>()

    fun db(): Map<Int, List<String>> = roster.mapValuestTo {it.value.toList}
}

Upvotes: 2

miensol
miensol

Reputation: 41608

Currently in Kotlin stdlib there are no implementations of List<T> (Map<K,V>) that would not also implement MutableList<T> (MutableMap<K,V>). However due to Kotlin's delegation feature the implementations become one liners:

class ImmutableList<T>(private val inner:List<T>) : List<T> by inner
class ImmutableMap<K, V>(private val inner: Map<K, V>) : Map<K, V> by inner

You can also enhance the creation of the immutable counterparts with extension methods:

fun <K, V> Map<K, V>.toImmutableMap(): Map<K, V> {
    if (this is ImmutableMap<K, V>) {
        return this
    } else {
        return ImmutableMap(this)
    }
}

fun <T> List<T>.toImmutableList(): List<T> {
    if (this is ImmutableList<T>) {
        return this
    } else {
        return ImmutableList(this)
    }
}

The above prevents a caller from modifying the List (Map) by casting to a different class. However there are still reasons to create a copy of the original container to prevent subtle issues like ConcurrentModificationException:

class ImmutableList<T> private constructor(private val inner: List<T>) : List<T> by inner {
    companion object {
        fun <T> create(inner: List<T>) = if (inner is ImmutableList<T>) {
                inner
            } else {
                ImmutableList(inner.toList())
            }
    }
}

class ImmutableMap<K, V> private constructor(private val inner: Map<K, V>) : Map<K, V> by inner {
    companion object {
        fun <K, V> create(inner: Map<K, V>) = if (inner is ImmutableMap<K, V>) {
            inner
        } else {
            ImmutableMap(hashMapOf(*inner.toList().toTypedArray()))
        }
    }
}

fun <K, V> Map<K, V>.toImmutableMap(): Map<K, V> = ImmutableMap.create(this)
fun <T> List<T>.toImmutableList(): List<T> = ImmutableList.create(this)

While the above is not hard to implement there are already implementations of immutable lists and maps in both Guava and Eclipse-Collections.

Upvotes: 19

Malt
Malt

Reputation: 30285

As mentioned here and here, you'd need to write your own List implementation for that, or use an existing one (Guava's ImmutableList comes to mind, or Eclipse Collections as Andrew suggested).

Kotlin enforces list (im)mutability by interface only. There are no List implementations that don't also implement MutableList.

Even the idiomatic listOf(1,2,3) ends up calling Kotlin's ArraysUtilJVM.asList() which calls Java's Arrays.asList() which returns a plain old Java ArrayList.

If you care more about protecting your own internal list, than about the immutability itself, you can of course copy the entire collection and return it as an List, just like Kotlin does: 

return ArrayList(original)

Upvotes: 11

Andrew White
Andrew White

Reputation: 53496

I know this a Kotlin specific question and @Malt is correct but I would like to add an alternative. In particular I find Eclipse Collections, formally GS-Collections, as a better alternative to Guava for most cases and it supplements Kotlin's built in collections well.

Upvotes: 3

Related Questions