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 ArrayList".

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

mutableListOf<T>() is an inline function invocation that returns a MutableList<T>. As of today, mutableListOf does return an instance of ArrayList.

ArrayList<String>() is a constructor invocation and cannot be inlined.

In other words, given:

 val a = mutableListOf<String>()
 val b = ArrayList<String>()
  • a is of type MutableList<String>
  • b is of type ArrayList<String>

At runtime, both a and b will hold an instance of ArrayList.

Note that inlining is particularly useful when combined with type reification, which justifies the existence of listOf, 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.