# Kotlin: Multi-dimensional Arrays – DEV Community

During time, all of us have labored with arrays. It’s a helpful knowledge construction to retailer a number of values of the identical kind in a single variable. Complicated utilization of arrays contains storing knowledge in 2D, 3D, or different multidimensional arrays. This permits us to signify issues like matrices, grids, and cubes successfully.

On this tutorial, we are going to particularly deal with declaring, initializing and utilizing 2D, 3D, and different multidimensional arrays within the Kotlin programming language.

## Pre-requisites

To grasp multi-dimensional arrays and lists in kotlin, you might want to have a correct understanding of 1D arrays. I’ve revealed an intuitive article about kotlin arrays just like this one, do read the article earlier than continuing.

## 2D Arrays in Kotlin

2D arrays are a handy strategy to retailer grid/board/matrix kind of knowledge.

If we dig deep into Kotlin Customary Library, the operate `arrayOf()` is definitely returning `Array<T>` the place `T` is the kind of the weather within the array. This successfully signifies that if we cross in `T` we get out an array `Array<T>`.

This implies if we cross in `arrayOf()` into the `arrayOf()` operate, we successfully get out `Array<Array<T>>` and that’s precisely the illustration of 2D Arrays!

### 2D Arrays with pre-defined knowledge

Let’s have a look at easy methods to make 2D arrays with predefined values:

``````val array = arrayOf(
arrayOf(1, 2, 3),
arrayOf(4, 5, 6),
arrayOf(7, 8, 9)
)
``````

This creates a 2D Kotlin array which is a group of 1D Kotlin arrays. This is a illustration of the array:

``````Basic Kind:
[[1 2 3], [4,5,6], [7,8,9]]

As a matrix:
1 2 3
4 5 6
7 8 9
``````

Once more, these arrays usually are not type-safe. You may add one other knowledge kind to the array with none challenge. To make it type-safe, we have to declare the kind of the array throughout initialization:

``````val array = arrayOf<Array<Int>>( // Declaring the kind offers error if knowledge sorts are blended
arrayOf(1, 2, 3),
arrayOf(4, 5, 6, "this string will give error"),
arrayOf(7, 8, 9)
)
``````

### 2D arrays with dynamic measurement

To create 2D lists the place we do not have a set recognized measurement, we use `mutableListOf<MutableList<T>>()` declaration the place `T` is the information kind we anticipate the interior lists to carry. We do not cross any preliminary worth as a result of the array shall be populated utilizing some logic later.

Let us take a look at it in motion:

``````val checklist = mutableListOf<MutableList<Int>>()

// The weather inside the interior lists could be something, the numbers under are simply an instance.

// `repeat()` takes in a quantity and iterates from 0 to number-1
repeat(4) {
// `row` is a brand new row within the array
val row = mutableListOf<Int>()

repeat(4) { col -> // `col` is a brand new column within the row, ranges from 0 to three
row += col
}

// Append the row to the array, can even use the `add()` operate
checklist += row
}

// for every checklist within the checklist, print its aspect in matrix kind
for(sublist in checklist) {
for (j in sublist.indices){
print("\$j ")
}

println() // new line after every row
}

/*
You may as well entry specific components like:
checklist[0][0] -> First aspect of the primary row
or
checklist.get(0).get(0) -> Similar as above
*/
``````

This code outputs the next:

``````0 1 2 3
0 1 2 3
0 1 2 3
0 1 2 3
``````

And therefore we are able to create dynamic lists in kotlin as per our wants.

## N-Dimensional Arrays in Kotlin

Utilizing the approaches mentioned above, it would not be arduous to create 3D, 4D or much more dimensional arrays.

If the dataset you could have is thought, you need to use the `arrayOf()` operate, or to have variable array knowledge, you’ll be able to go forward with `mutableListOf()` capabilities to create the arrays.

## Conclusion

On this tutorial you discovered in regards to the arrays and mutable lists in kotlin utilizing `arrayOf()` and `mutableListOf()` capabilities.

These capabilities assist you to to create arrays and lists of any knowledge kind in Kotlin, to retailer values and carry out actions based mostly on that knowledge.

I hope you discover this tutorial helpful. Share it with your folks who’re starting with kotlin!