How to Convert a List to a Map in Kotlin

By the end of this page, you will understand how to turn a List into a Map in Kotlin, when to use associate, associateWith, associateBy, and toMap(), and how to choose the right approach depending on the data you have.

In Kotlin, a List and a Map are different collection types:

• A List stores ordered values.
• A Map stores key-value pairs.

That means a plain list like this:

val list = listOf("a", "b", "c", "d")

cannot become a map by itself unless you decide:

• what the keys should be, and
• what the values should be.

If you want the strings to become the keys, you must also decide what value each key should map to.

For example:

• string → index
• string → same string
• string → length
• string → custom object

This is why toMap() is not usually the first tool for converting a plain List<String> into a Map. The toMap() function is mainly used when your list already contains pairs, such as:

val pairs = listOf(
     to ,
     to 
)

 map = pairs.toMap()

Think of a List as a row of items on a shelf:

• position 0 → "a"
• position 1 → "b"
• position 2 → "c"
• position 3 → "d"

A Map is more like a set of labeled drawers:

• drawer "a" → some value
• drawer "b" → some value
• drawer "c" → some value

To convert the shelf into labeled drawers, you need to decide two things:

1. What label goes on each drawer? The key
2. What goes inside each drawer? The value

If your list items themselves are the labels, then you still need to choose the value for each one.

1. Use associateWith when list items should be the keys

If the list values should become the keys, associateWith is often the clearest choice.

val list = listOf("a", "b", "c", "d")
val map = list.associateWith { it.length }

println(map)

Output:

{a=1, b=1, c=1, d=1}

Here:

• each string becomes a key
• it.length becomes the value

2. Use associateWith { it } to map each item to itself

val list = listOf("a", "b", "c", "d")
val map = list.associateWith { it }

println(map)

Output:

{a=a, b=b, c=c, d=d}

This creates a map where each string is both the key and the value.

Consider this example:

val list = listOf("a", "b", "c")
val map = list.associateWith { it.length }
println(map)

Step by step:

1. listOf("a", "b", "c") creates a list containing three strings.
2. associateWith { it.length } loops through each item in the list.
3. For the first item, it is "a".
   • key = "a"
   • value = "a".length, which is 1
4. For the second item, it is "b".
   • key = "b"
   • value = 1
5. For the third item, it is "c".
   • key = "c"
   • value = 1

Converting a list to a map is useful when you want faster access to data by a specific key.

Common use cases

• User lookup by username

  val usernames = listOf("alice", "bob", "carol")
  val userMap = usernames.associateWith { "active" }
  

• Product names mapped to prices or IDs

  val products = listOf("Pen", "Book", "Bag")
  val productCodes = products.withIndex().associate { it.value to it.index + 100 }
  

• API data transformation After fetching a list of objects, you may convert it to a map by ID for quick lookup.

• Configuration values A list of setting names can be transformed into default values.

• Caching If you repeatedly search a list for an item by name, converting to a map can improve readability and lookup speed.

In real Kotlin projects, developers usually convert lists to maps for lookup, validation, and transformation.

Common patterns

Lookup by a unique field

data class User(val id: Int, val name: String)

val users = listOf(
    User(1, "Alice"),
    User(2, "Bob")
)

val usersById = users.associateBy { it.id }

This is one of the most common patterns in production code.

Build computed values

val words = listOf("cat", "house", "sun")
val wordLengths = words.associateWith { it.length }

Validation and normalization

val fields = listOf("name", "email", "phone")
val validationState = fields.associateWith { false }

Guard against missing keys

Once you have a map, you can safely check values:

1. Using toMap() on a plain list

This does not work for a List<String> because toMap() expects pairs.

val list = listOf("a", "b", "c")
// val map = list.toMap() // Incorrect

Fix

Use associate, associateWith, or first convert items into pairs.

val map = list.associateWith { it }

2. Forgetting that map values are required

A map always needs both a key and a value.

Broken thinking:

• “I want a map of just keys.”

In Kotlin, that still means you must choose a value.

Possible fixes:

val map1 = list.associateWith { true }
val map2 = list.associateWith { it }
val map3 = list.withIndex().associate { it.value to it.index }

3. Duplicate keys overwrite earlier values

// List<String>
val list = listOf("a", "b", "c")

Most useful conversions

// element -> element
val map1 = list.associateWith { it }

// element -> computed value
val map2 = list.associateWith { it.length }

// custom key -> custom value
val map3 = list.associate { it to it.uppercase() }

// element -> index
val map4 = list.withIndex().associate { it.value to it.index }

Use toMap() only for pairs

val pairs = listOf("a" to 1, "b" to 2)
val map = pairs.toMap()

Quick rules

• A Map always has keys and values.
• List<String> does not directly become a map unless you define values.
• associateWith = element becomes key.
• associateBy = lambda result becomes key.

How do I convert a list of strings to a map in Kotlin?

Use associateWith if each string should become a key:

val map = list.associateWith { it.length }

Can I use toMap() on a List<String>?

No. toMap() expects a collection of pairs like List<Pair<K, V>>.

What if I want each string to map to itself?

Use:

val map = list.associateWith { it }

How do I map each string to its index?

Use withIndex() with associate:

val map = list.withIndex().associate { it.value to it.index }

What is the difference between associateBy and associateWith?

• associateBy: computes the key, keeps the object as value

• List — the starting collection type before transforming into a map.
• Map — the target collection type that stores key-value pairs.
• Pair — important because toMap() works with collections of pairs.
• associate — useful when you want full control over both key and value.
• associateWith — ideal when list elements should become map keys.
• associateBy — useful when working with objects and choosing a property as the key.
• withIndex — helpful when converting list items into index-based maps.
• groupBy — related when you want multiple items per key instead of one.
• filter — often used before converting a collection into a map.
• map — commonly used to transform data before creating a map.