Difference between ArrayList<String>() and mutableListOf<String>() in Kotlin
The only difference between the two is communicating your intent.
When you write
val a = mutableListOf(), you're saying "I want a mutable list, and I don't particularly care about the implementation". When you write, instead,
val a = ArrayList(), you're saying "I specifically want an
In practice, in the current implementation of Kotlin compiling to the JVM, calling
mutableListOf will produce an
ArrayList, and there's no difference in behaviour: once the list is built, everything will behave the same.
Now, let's say that a future version of Kotlin changes
mutableListOf to return a different type of list.
Likelier than not, the Kotlin team would only make that change if they figure the new implementation works better for most use cases.
mutableListOf would then have you using that new list implementation transparently, and you'd get that better behaviour for free. Go with
mutableListOf if that sounds like your case.
On the other hand, maybe you spent a bunch of time thinking about your problem, and figured that
ArrayList really is the best fit for your problem, and you don't want to risk getting moved to something sub-optimal. Then you probably want to either use
ArrayList directly, or use the
arrayListOf factory function (an
ArrayList-specific analogue to
mutableListOf<T>() is an inline function invocation that returns a
MutableList<T>. As of today,
mutableListOf does return an instance of
ArrayList<String>() is a constructor invocation and cannot be inlined.
In other words, given:
val a = mutableListOf<String>() val b = ArrayList<String>()
ais of type
bis of type
At runtime, both
b will hold an instance of
Note that inlining is particularly useful when combined with type reification, which justifies the existence of
mutableListOf and the like.
As you can see in sources:
public inline fun <T> mutableListOf(): MutableList<T> = ArrayList()
So, there is no difference, just a convenience method.