Learn how to use collection types to keep your data organized.

Arrays

`["Hip", "hip", "array!"]` We have learned about how to store groups of data into arrays in Swift. 🙌

Here are some of the things that we covered:

- An array is a list of ordered items.
```swift
var evenNumbers = [2, 4, 6, 8, 10]
```
- The first index in an array is 0.
- The `.count` property that returns the size of an array.
- Some of the methods that come with arrays:
  - `.append()`: adding an item to the end
  - `.insert()`: adding an item to an index
  - `.remove()`: removing an item from an index 
- The `for`-`in` loop can be used to iterate through an array.

Download the [Arrays: Cheat Sheet](https://www.codecademy.com/learn/learn-swift/modules/learn-swift-arrays/reference) for referencing the content covered in this lesson.



Review

In Swift, an array stores values of the same type in an ordered list. 

To create an empty array of a certain type, we can use the initializer syntax:

```swift
var name = [Type]()
```

Suppose we want to create an empty array called `scores` of the type `Int`:

```swift
var scores = [Int]()
```

Now that we've initialized the `scores` array, we can add integers (and only integers) inside. 

**Note:** Arrays can only store items of the same data type. The type of the array cannot be changed after it's declared.

We'll also figure out how to remove, change, and manipulate the array later on, but let's start with creating one.

Creating an Empty Array

What happens if we want to iterate through items of an array? We can use a `for`-`in` loop!

The syntax looks like the following:

```swift
for item in array {
  // Loop body
}
```

For example, suppose we have a `String` array that looks like this:

```swift
var employees = ["Michael", "Dwight", "Jim", "Pam", "Andy"]
```

We can write a `for`-`in` loop like so:

```swift
for item in employees {
  print(item)
}

// Prints "Michael"
// Prints "Dwight"
// Prints "Jim"
// Prints "Pam"
// Prints "Andy"
```

This is a powerful tool for working with and manipulating a large amount of data.

Iterating Over an Array

We live in an increasingly connected world where information flows between us and the apps that we interact with every day. Historically that information was stored in filing cabinets but, today, most of it is stored on computers.

When we write programs that capture data about our surroundings, the need for storing collections of data will arise. For example, we might need to store:

- A list of player scores in a mobile game
- A list of order prices in a food delivery app
- A list of hashtags on a social platform

We are familiar with storing an individual piece of data using an `Int`, `Double`, or `String` variable, but how do we store a group of `Int`s, `Double`s, or `String`s? Well, that's where arrays come into play. 

An _array_ stores an ordered collection of values.

In this lesson, we will learn how to create and use an array, as well as some of its properties and methods.

An array of the Learn Swift team: Sonny, Alex, Kenny, Galina, and Tim!

Introduction to Arrays

When working with arrays, we might need to add additional elements to it after initialization.

We can add a new item to the end of an array by calling the array's [`.append()`](https://developer.apple.com/documentation/swift/array/3126937-append) method:

```swift
name.append(value)
```

For example, suppose we have an array called `gymBadges`:

```swift
var gymBadges = ["Boulder", "Cascade"]
```

We can add a new item, `"Thunder"`, to the end of the array by:

```swift
gymBadges.append("Thunder") 

// ["Boulder", "Cascade", "Thunder"]
```

Alternatively, append an array of one or more items with the addition assignment operator `+=`:

```swift
gymBadges += ["Thunder", "Rainbow"]

// ["Boulder", "Cascade", "Thunder", "Rainbow"]
```


.append() Method

Now that we have an array, how do we retrieve an individual value? This is where index comes into play.

An _index_ refers to an item’s position within an ordered list. Arrays in Swift are zero-indexed, meaning the first item has index 0, the second index 1, and so on.

For example, suppose we have a [`String`](https://developer.apple.com/documentation/swift/string) array with all the [vowels](https://en.wikipedia.org/wiki/Vowel):

```swift
var vowels = ["a", "e", "i", "o", "u"]
```


- The item at index 0 is `"a"`.
- The item at index 1 is `"e"`.
- The item at index 2 is `"i"`.
- The item at index 3 is `"o"`.
- The item at index 4 is `"u"`.

To retrieve individual elements, we can use the _subscript syntax_, `array[index]`. The subscript syntax uses square brackets, `[` `]`, around an index value.

For example:

```swift
print(vowels[0])     // Prints: a
print(vowels[1])     // Prints: e
print(vowels[2])     // Prints: i
print(vowels[3])     // Prints: o
print(vowels[4])     // Prints: u
```

Index

We learned one way to create an array, but there's another.

We can also declare and initialize an array with a list of values, separated by commas, and surrounded by a pair of square brackets.

The syntax to create an array this way looks like:

```pseudo
var name = [list of values]
```

Suppose we want to create an array called `location` with Codecademy HQ's [latitude and longitude](https://en.wikipedia.org/wiki/Geographic_coordinate_system):

```swift
var location = [40.7245, -73.9979]
```

Due to Swift's built-in type inference, the type of the array is inferred. To be explicit:

```swift
var location: [Double] = [40.7245, -73.9979]
```

Let's try creating arrays using this new approach.

Creating an Array Literal

Previously, we learned how to add an item to the end of the array, but how do we add an item in the middle or even the start? And how do we remove an item?

Suppose we have an array:

```swift
var moon = ["🌖", "🌗", "🌘", "🌑"]
```

To insert an item in the array at a specified index, we can call the [`.insert()`](https://developer.apple.com/documentation/swift/array/3126951-insert) method.

```swift
moon.insert("🌕", at: 0)

// ["🌕", "🌖", "🌗", "🌘", "🌑"]
```

The `.insert()` method takes two values:

- The value to be inserted.
- The `at:` and the index of the insertion.

So the code above inserted `"🌕"` at index 0.

---

To remove an item from the array, call the array's `.remove()` method:

```swift
moon.remove(at: 4)

// ["🌕", "🌖", "🌗", "🌘"]
```

The `.remove()` method only takes in one value, `at:` and the index of removal.

So the code above removed `"🌑"` at index 4.

.insert() and .remove() Methods

_Properties_ in Swift, allow us to access a value that is specific to a particular structure. We can use the [`.count`](https://www.codecademy.com/resources/docs/swift/arrays) property of an array to give us a number value of elements inside the array.

For example, suppose we have an array called `grocery` with some emojis:

```swift
var grocery = ["🥓", "🥞", "🍪", "🥛", "🍊"]
```

When we print out `grocery.count`:

```swift
print(grocery.count)
```

The output will look like this:

```
5
```

This property will come in extra handy when the array is lengthy.