# Arrays

Arrays are an ordered list of some type. In Swift, arrays are very similar to python or ArrayLists in java–they are entirely mutable in terms of both their contents and length.

#### Typing

Generally speaking, you will see the type for an array as their element type enclosed with square brackets `[someType]`. For example, a list of integers would have type `[Int]`. This works for nested lists as well. Say we have a 2-dimensional list of integers, an element in the top-level list would be a list of integers. Therefore, the type of the original list is `[[Int]]`. In fact, the type of any n-dimensional list of type `m` has n pairs of square brackets surrounding `m`.

The reason I preface the previous paragraph with "generally", is that we normally code in array literals. The common notation being `[ element1, element2, ... ]`. But arrays are actually a generic–exactly as you would see in java–and thus can be represented as such: `[Int]` is the same as `Array<Int>`. You will rarely see the array generic as it is convention, and is a lot cleaner, to use literals. So you don't really need to worry about this other form of arrays.

#### Creation

There are many different ways to create arrays depending on how you want them to be initialized. If you want them to be completely empty, use the following:

1. Use a type annotation to declare the type of the list and then write the empty list
2. Instantiate the type literal: `var x = [Int]()`

```swift
var x: [Int] = []
// x: [Int] = []
var y = [Int]()
// y: [Int] = []
```

These are functionally the same, so it comes down to your stylistic preference.

If you have data that you want to populate the list with this gets quite a bit easier because we can take advantage of inferred types. We simply write a typical array literal:

```swift
var z = [1, 2, 3]
// z: [Int] = [1, 2, 3]
```

There is one other way to initialize a list that is quite useful. While arrays are mutable, it may be useful to use a list immutably (in the sense of their length). For example, if you are making a queue or a hashmap, it may make sense to keep an array limited to a certain size. To do this, we need to start with an array of a certain size. This is an instance where we need to turn to the verbose array form. To do this, we use the `Array(repeating: T, count: Int)` initializer, where `T` is an instance of a type. This will create a list whose length is `count`, where every element in the list is set to be `repeating`. For those of you comfortable with generics, you may notice we never specify what `T` is. This is again because of inferred typing.&#x20;

```swift
var emptyList = Array(repeating: 0, count: 10)
// emptyList: [Int] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
```

The last way to instantiate an array is with a sequence. You can create array slices from arrays:

```swift
let myNumbers = [0, 1, 2, 3]
// myNumbers: [Int] = [0, 1, 2, 3]

let mySlice = myNumbers[1...2]
// mySlice: ArraySlice<Int> = [1, 2] <- this is a simplification
```

A slice is not an array (this has to do with protocols with associated types–an advanced topic). `ArraySlice` is something we call a `Sequence`. For this context, this means that if you take an array slice and want to convert it to an array, you can use `Array(_:sequence)`. If that didn't make sense, you can come back after reading the lower sections. And if it still doesn't we don't use this very much it is okay. Just remember, if you get something of array slice, you may want to re-read this section.

```swift
var emptyList = Array(repeating: 0, count: 10)
// emptyList: [Int] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

var mySlice = emptyList[1..<3]
// mySlice: ArraySlice<Int> = [0, 0]

var myNewArray = Array(mySlice)
// myNewArray: [Int] = [0, 0]
```

I am sure there are more ways to instantiate lists–these are just the ones I have found particularly useful and common.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://ios-course.cornellappdev.com/resources/swift-foundations/arrays.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.