Swift Tutorial

Swift Data Types

Swift Control Flow

Swift Functions

Swift Collections

Swift OOPs

Swift Additional Topics

Swift - Arrays

Arrays are one of the fundamental collection types in Swift, used to store lists of items of the same type. Here's a comprehensive guide on arrays in Swift:

1. Creating Arrays:

Using array literals:

let fruits = ["apple", "banana", "cherry"]

Creating an empty array:
```
var emptyArray = [String]()
```

Creating an array with a default value:

var defaultArray = Array(repeating: 0, count: 5)  // [0, 0, 0, 0, 0]

2. Accessing and Modifying Arrays:

Accessing an element by index:
```
let firstFruit = fruits[0]  // apple
```

Changing an element by index:

var numbers = [1, 2, 3, 4]
numbers[1] = 10  // [1, 10, 3, 4]

Appending an element:
```
numbers.append(5)  // [1, 10, 3, 4, 5]
```

Inserting at a specific index:

numbers.insert(6, at: 2)  // [1, 10, 6, 3, 4, 5]

Removing an element:

numbers.remove(at: 3)  // [1, 10, 6, 4, 5]

Removing the last element:
```
numbers.removeLast()  // [1, 10, 6, 4]
```

3. Iterating Over Arrays:

Using a for-in loop:

for fruit in fruits {
    print(fruit)
}

Using enumerated() to get both index and element:

for (index, fruit) in fruits.enumerated() {
    print("Item \(index + 1): \(fruit)")
}

4. Array Properties and Methods:

Counting the number of items:
```
let count = fruits.count
```

Checking if an array is empty:

if fruits.isEmpty {
    print("The array is empty.")
}

Finding the index of an element:

if let index = fruits.firstIndex(of: "banana") {
    print("Banana is at position \(index)")
}

5. Multi-dimensional Arrays:

Arrays can also contain other arrays, creating multi-dimensional arrays:

let matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
let firstRow = matrix[0]  // [1, 2, 3]
let firstItem = matrix[0][0]  // 1

6. Type Safety:

Swift arrays are type-safe. If you declare an array to hold strings, for example, you can't accidentally insert an integer or any other type:

var names = ["Anna", "Brian"]
// names.append(10)  // Error: 'Int' is not of type 'String'

Arrays in Swift come with a suite of useful methods and properties that make them powerful and easy to work with. They're also backed by the efficiency of the underlying platform, making them a great choice for storing ordered lists of items.

How to create arrays in Swift:
- Description: Arrays can be created in Swift using the array literal syntax, specifying the type of elements the array will contain.
- Code:
```
// Array of integers
let numbers = [1, 2, 3, 4, 5]

// Array of strings
let fruits = ["Apple", "Banana", "Orange"]
```

Swift array initialization:

Description: Arrays can be initialized using the Array constructor, specifying the type of elements.

Code:

// Initializing an array of characters
let characters = Array("Swift")

// Initializing an array of integers with repeated values
let repeatedNumbers = Array(repeating: 0, count: 5)

Adding and removing elements in Swift arrays:

Description: Elements can be added to and removed from arrays using methods like append, insert, remove, and others.

Code:

var fruits = ["Apple", "Banana", "Orange"]

// Adding an element to the end
fruits.append("Grapes")

// Inserting an element at a specific index
fruits.insert("Cherry", at: 1)

// Removing an element
fruits.remove(at: 2)

Accessing array elements in Swift:

Description: Array elements can be accessed using subscript syntax and indices. Indices start from zero.

Code:

let numbers = [10, 20, 30, 40, 50]

// Accessing an element
let firstElement = numbers[0]

// Accessing a range of elements
let subset = numbers[1...3] // [20, 30, 40]

Swift array operations:

Description: Arrays support various operations such as sorting, filtering, and mapping using higher-order functions like sorted, filter, and map.

Code:

let numbers = [5, 2, 8, 1, 7]

// Sorting
let sortedNumbers = numbers.sorted()

// Filtering
let filteredNumbers = numbers.filter { $0 > 5 }

// Mapping
let squaredNumbers = numbers.map { $0 * $0 }

Multidimensional arrays in Swift:
- Description: Swift supports multidimensional arrays, which are arrays of arrays, to represent tables or grids of values.
- Code:
```
// 2D array (matrix)
var matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

// Accessing an element in the matrix
let element = matrix[1][2] // 6
```

Swift array iteration:

Description: Arrays can be iterated using for-in loops to perform operations on each element.

Code:

let fruits = ["Apple", "Banana", "Orange"]

// Iterating through array elements
for fruit in fruits {
    print(fruit)
}

Common array functions in Swift:

Description: Swift provides common array functions like count, isEmpty, and others to perform operations on arrays.

Code:

let colors = ["Red", "Green", "Blue"]

// Checking the number of elements
let count = colors.count

// Checking if the array is empty
let isEmpty = colors.isEmpty