Hey there, great questions—let's unpack this clearly!

You’re exactly right about the temporary Pair objects! The to operator in Kotlin is just a handy extension function that returns a Pair instance. So every a to b creates a new Pair behind the scenes, which the mapOf function then iterates over to build the final Map.

But here’s the key point: for most everyday code, the tiny overhead of these temporary pairs is totally negligible. The tradeoff is well worth it because this syntax is super readable and concise. Kotlin’s design philosophy prioritizes expressiveness and developer productivity first, and unless you’re working in a tight loop or a code path that’s called millions of times, the performance hit isn’t noticeable at all. It’s way better to have code that’s easy to write, read, and maintain than to optimize prematurely for a problem that might not even exist.

When you’re in a scenario where every nanosecond counts, here are the top approaches to avoid unnecessary object overhead:

• Use a mutable Map with direct put calls
  Skip the Pair objects entirely by initializing a mutable Map and adding entries directly. If you need an immutable Map afterward, you can convert it, but keep in mind that toMap() creates a copy—so if mutability isn’t a problem, stick with the mutable instance:

  val optimizedMap = HashMap<String, Int>().apply {
      put("apple", 1)
      put("banana", 2)
      put("cherry", 3)
  }
  // If you need an immutable Map:
  val immutableMap = optimizedMap.toMap()
  

• Pre-specify initial capacity
  If you know exactly how many entries your Map will have, set the initial capacity when creating the HashMap. This avoids expensive resizing operations as the Map grows:

  val sizedMap = HashMap<String, Int>(3).apply {
      put("apple", 1)
      put("banana", 2)
      put("cherry", 3)
  }
  

• Leverage JVM’s optimized Map factories (Java 9+)
  On the JVM, you can use java.util.Map.of() for small numbers of entries (up to 10). This method returns a specialized, immutable Map implementation that doesn’t rely on temporary Pair objects—Kotlin can call this directly:

  val jvmOptimizedMap = Map.of("apple", 1, "banana", 2, "cherry", 3)
  

• Avoid unnecessary immutability conversions
  If your use case allows a mutable Map, don’t waste cycles converting it to immutable. Only use immutable Maps if you need the safety guarantees they provide.

Remember: always profile first before optimizing! Even in performance-critical code, you should only switch away from the concise mapOf syntax if your profiling tools show that the Pair creation is actually a bottleneck.

内容的提问来源于stack exchange，提问作者Itay Maman