Allocation

Learn object allocation and GC impact.

Allocation and GC

Allocation is the act of placing a new object on the JVM heap. Every allocation brings the garbage collector (GC) closer to a run; GC pauses can slow an app.

For example List(n) { it } allocates n boxed Integer objects. Using IntArray(n) instead keeps unboxed primitives and lowers allocation. You avoid creating objects in tight loops and reuse them. The allocInfo model in this lesson shows the concept.

Reducing allocation

Ways to reduce allocation: use primitive arrays, pool objects and avoid unnecessary intermediate collections.

For example Array<Int> creates 100 boxed objects while IntArray(100) does not. StringBuilder avoids creating a new String on every concatenation. Sequence removes intermediate lists. These small changes make a big difference in hot loops.

Exercise Write allocInfo

Define fun allocInfo(): String. It should return "Allocation". In main, write println(allocInfo()).

Show example solution

fun allocInfo(): String = "Allocation"
fun main() {
    println(allocInfo())
}

Test yourself

Complete the alloc body

fun alloc(n: Int): List<Int> = List(n) { ____ }

Show answer

fun alloc(n: Int): List<Int> = List(n) { it }

Match the allocation parts

allocation

Heap allocation
GC

Garbage collector
IntArray

Unboxed array
StringBuilder

String concat
Which reduces allocation?
```
A primitive array allocates fewer objects.
```
- A new List every loop
- String concatenation
- Creating a data class
- IntArray (instead of boxed Array)
Show answer

IntArray (instead of boxed Array) — IntArray holds unboxed primitives; allocation drops.

Next lesson: inline

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies