How to Initialize an ArrayList in Kotlin
Tags: kotlin, java, android, beginners
Published: 2019-06-27 22:15:18

For those of you familiar with the [How to Python](https://therenegadecoder.com/series/how-to-python/) series, I thought it would be fun to try my hand at some other languages I’ve been using lately. Today, let’s learn how to initialize an ArrayList in Kotlin.

## Problem Introduction

As someone who came from Java, I often find myself using the ArrayList class to store data. Unfortunately, there’s no clean way of initializing an ArrayList in Java, so I wondered if Kotlin had improved on that issue. For reference, here’s what I don’t want to do:

```java
ArrayList<Integer> list = new ArrayList<Integer>()
list.add(7)
list.add(-4)
list.add(3)
```

As you can probably imagine, this solution does not scale well. In fact, I don’t even think it reads well. There’s just too much redundant information. I would prefer to be able to do something like the following:

```java
ArrayList<Integer> list = new ArrayList<Integer>(7, -4, 3)
```

And, for larger data sets, it would be nice to be able to spread the values over multiple lines:

```java
ArrayList<Integer> list = new ArrayList<Integer>( 
    7, -4, 3, 2, 1, 3, 6, 5, 9, 11, 
    10, 7, -5, -6, 13, 6, -11, 13, 2, 1
)
```

Unfortunately, that’s just not the case. There are some nasty workarounds, but I was hoping Kotlin would improve on the Java conventions a bit.

## Solutions

Fortunately, Kotlin has improved quite a bit on Java’s verbosity, so I promise there’s a better way to create an ArrayList. It’s just a matter of how.

### Initializing an ArrayList by Brute Force

Naturally, we can translate the Java solution almost directly:

```kotlin
val list = ArrayList<Int>()
list.add(7)
list.add(-4)
list.add(3)
```

Here, we’ve created an empty ArrayList of integers. Then, we populated that list one item at a time using the `add()` method.

Of course, we’d love something better than this! Let’s see what Kotlin has to offer.

### Initializing an ArrayList by Conversion

One way to reduce some of the code from above is to create an Array before converting it into an ArrayList:

```kotlin
val list = intArrayOf(7, -4, 3).toCollection(ArrayList())
```

In a single line of code, we’re able to create an array of integers using the ideal syntax. From that array, we can obtain an ArrayList using the `toCollection()` method and passing an empty ArrayList. The `toCollection()` method then populates the ArrayList with all the values in the array.

Obviously, this isn’t ideal as we have to convert between the two types. It would be much nicer to be able to create and initialize an ArrayList directly. Fortunately, we can!

### Initializing an ArrayList with arrayListOf

As it turns out, the collections library includes a function for building an ArrayList in Kotlin directly:

```kotlin
val list = arrayListOf<Int>(7, -4, 3)
```

I’m not totally sure how this method works under the hood, but I imagine it works similar to our brute force solution:

```kotlin
fun <T> arrayListOf(vararg elements: T): ArrayList<T> { 
    val list = ArrayList<T>() 
    for (element in elements) { 
        list.add(element) 
    } 
    return list
}
```

In any case, we have a concise solution for building up an ArrayList. That’s exciting!

## Performance

Since I got into the habit of measuring performance in Python, I thought I could transition that idea over to Kotlin. Fortunately, there is a standard function which will do just that: `measureNanoTime`. We’ll be using that to test each of the code snippets above:

```kotlin
import kotlin.system.measureNanoTime

val bruteForceTime = measureNanoTime { 
    val list = ArrayList<Int>() 
    list.add(7) 
    list.add(-4) 
    list.add(3)
}

val conversionTime = measureNanoTime { 
    val list = intArrayOf(7, -4, 3).toCollection(ArrayList())
}

val arrayListOfTime = measureNanoTime { 
    val list = arrayListOf<Int>(7, -4, 3)
}

println("Brute Force: $bruteForceTime")
println("Conversion: $conversionTime")
println("ArrayListOf: $arrayListOfTime")
```

In my case, the brute force method was significantly faster than the other two methods, but I’m not sure how these functions scale with more input. Feel free to try and let me know. At any rate, here are the results:

> Brute Force: 38700
> 
> Conversion: 14728800
> 
> ArrayListOf: 6319000

For this test, I ended up using `measureNanoTime` over `measureTimeMillis` because I kept getting a value of zero for the brute force method. Now, that makes sense!

For reference, I tested everything on Windows 10 using Android Studio to setup a scratch file called `scratch.kts`. Also, I used Kotlin 1.3.31.

## A Little Recap

As always, here are all the solutions in one convenient place:

```kotlin
// Brute force
val list = ArrayList<Int>()
list.add(7)
list.add(-4)
list.add(3)

// Array conversion
val list = intArrayOf(7, -4, 3).toCollection(ArrayList())

// Direct method
val list = arrayListOf<Int>(7, -4, 3)
```

Since I’m just starting to play with Kotlin, this may seem like a pretty trivial tutorial. That said, I guarantee I’ll start digging into more interesting topics. For instance, I’m already excited to start mirroring some of the Python articles.

While you’re here, why not support The Renegade Coder by [becoming a member](https://therenegadecoder.com/members/). You’ll get access to all kinds of fun articles like:

- [Working with Challenging College Students](https://therenegadecoder.com/blog/working-with-challenging-college-students/)
- [11 Reasons Why I Quit My Engineering Career](https://therenegadecoder.com/blog/11-reasons-why-i-quit-my-engineering-career/)

Of course, [you’re welcome to just hop on the newsletter](http://eepurl.com/dB-ABr) and decide at a later date. Either way, I appreciate the support.

The post [How to Initialize an ArrayList in Kotlin](https://therenegadecoder.com/code/how-to-initialize-an-arraylist-in-kotlin/) appeared first on [The Renegade Coder](https://therenegadecoder.com).