Working with Array and Dictionary Collections in Swift
| Previous | Table of Contents | Next |
| An Introduction to Swift Inheritance | The iOS 8 Application and Development Architecture |
<google>BUY_IOS8</google>
Arrays and dictionaries in Swift are objects that contain collections of other objects. In this chapter, we will cover some of the basics of working with arrays and dictionaries in Swift.
Mutable and Immutable Collections
Collections in Swift come in mutable and immutable forms. The contents of immutable collection instances cannot be changed after the object has been initialized. To make a collection immutable, assign it to a constant when it is created. Collections are mutable, on the other hand, if assigned to a variable.
Swift Array Initialization
An array is a data type designed specifically to hold multiple values in a single ordered collection. An array, for example, could be created to store a list of String values. A single Swift based array is only able to store values that are of the same type. An array of String values, therefore, could not also contain an Int value. The type of an array can be specified specifically using type annotation, or left to the compiler to identify using type inference.
An array may be initialized with a collection of values (referred to as an array literal) at creation time using the following syntax:
var variableName: [type] = [value 1, value2, value3, ……. ]
The following code creates a new array assigned to a variable (thereby making it mutable) that is initialized with three string values:
var treeArray = ["Pine", "Oak", "Yew"]
Alternatively, the same array could have been created immutably by assigning it to a constant:
let treeArray = ["Pine", "Oak", "Yew"]
In the above instance, the Swift compiler will use type inference to decide that the array contains values of String type and prevent values of other types being inserted into the array elsewhere within the application code.
Alternatively, the same array could have been declared using type annotation:
var treeArray: [String] = ["Pine", "Oak", "Yew"]
Arrays do not have to have values assigned at creation time. The following syntax can be used to create an empty array:
var variableName = [type]()
Consider, for example, the following code which creates an empty array designated to store floating point values and assigns it to a variable named priceArray:
var priceArray = [Float]()
Another useful initialization technique allows an array to be initialized to a certain size with each array element pre-set with a specified default value:
var nameArray = [String](count: 10, repeatedValue: "My String")
When compiled and executed, the above code will create a new 10 element array with each element initialized with a string that reads “My String”.
Finally, a new array may be created by adding together two existing arrays (assuming both arrays contain values of the same type). For example:
var firstArray = ["Red", "Green", "Blue"] var secondArray = ["Indigo", "Violet"] var thirdArray = firstArray + secondArray
Working with Arrays in Swift
Once an array exists, a wide range of methods and properties are provided for working with and manipulating the array content from within Swift code, a subset of which is as follows:
Array Item Count
A count of the items in an array can be obtained by accessing the array’s count property:
var treeArray = ["Pine", "Oak", "Yew"] var itemCount = treeArray.count println(itemCount)
Whether or not an array is empty can be identified using the array’s Boolean isEmpty property as follows:
var treeArray = ["Pine", "Oak", "Yew"]
if treeArray.isEmpty {
// Array is empty
}
Accessing Array Items
A specific item in an array may be accessed or modified by referencing the item’s position in the array index (where the first item in the array has index position 0) using a technique referred to as index subscripting. In the following code fragment, the string value contained at index position 2 in the array (in this case the string value “Yew”) is output by the println call:
var treeArray = ["Pine", "Oak", "Yew"] println(treeArray[2])
This approach can also be used to replace the value at an index location:
treeArray[1] = "Redwood"
The above code replaces the current value at index position 1 with a new String value that reads “Redwood”.
Appending Items to an Array
Items may be added to an array using either the append method or + and += operators. The following, for example, are all valid techniques for appending items to an array:
treeArray.append("Redwood")
treeArray += ["Redwood"]
treeArray += ["Redwood", "Maple", "Birch"]
Inserting and Deleting Array Items
New items may be inserted into an array by specifying the index location of the new item in a call to the array’s insert(atIndex:) method. An insertion preserves all existing elements in the array, essentially moving them to the right to accommodate the newly inserted item:
treeArray.insert("Maple", atIndex: 0)
Similarly, an item at a specific array index position may be removed using the removeAtIndex method call:
treeArray.removeAtIndex(2)
To remove the last item in an array, simply make a call to the array’s removeLast method as follows:
treeArray.removeLast()
Array Iteration
The easiest way to iterate through the items in an array is to make use of the for-in looping syntax. The following code, for example, iterates through all of the items in a String array and outputs each item to the console panel:
var treeArray = ["Pine", "Oak", "Yew", "Maple", "Birch", "Myrtle"]
for tree in treeArray {
println(tree)
}
Upon execution, the following output would appear in the console:
Pine Oak Yew Maple Birch Myrtle
<google>BUY_IOS8</google>
Swift Dictionary Collections
String dictionaries allow data to be stored and managed in the form of key-value pairs. Dictionaries fulfill a similar purpose to arrays, except each item stored in the dictionary has associated with it a unique key (to be precise, the key is unique to the particular dictionary object) which can be used to reference and access the corresponding value. Currently only String, Int, Double and Bool data types are suitable for use as keys within a Swift dictionary.
Swift Dictionary Initialization
A dictionary is a data type designed specifically to hold multiple values in a single unordered collection. Each item in a dictionary consists of a key and an associated value. The data types of the key and value elements type may be specified specifically using type annotation, or left to the compiler to identify using type inference.
A new dictionary may be initialized with a collection of values (referred to as a dictionary literal) at creation time using the following syntax:
var variableName: [key type: value type] = [key 1: value 1, key 2: value2 ... ]
The following code creates a new array assigned to a variable (thereby making it mutable) that is initialized with four key-value pairs in the form of ISBN numbers acting as keys for corresponding book titles:
var bookDict = ["100-432112" : "Wind in the Willows",
"200-532874" : "Tale of Two Cities",
"202-546549" : "Sense and Sensibility",
"104-109834" : "Shutter Island"]
In the above instance, the Swift compiler will use type inference to decide that both the key and value elements of the dictionary are of String type and prevent values or keys of other types being inserted into the dictionary.
Alternatively, the same array could have been declared using type annotation:
var bookDict: [String: String] =
["100-432112" : "Wind in the Willows",
"200-532874" : "Tale of Two Cities",
"202-546549" : "Sense and Sensibility",
"104-109834" : "Shutter Island"]
As with arrays, it is also possible to create an empty dictionary, the syntax for which reads as follows:
var variableName = [key type: value type]()
The following code creates an empty dictionary designated to store integer keys and string values:
var myDictionary = [Int: String]()
Dictionary Item Count
A count of the items in a dictionary can be obtained by accessing the dictionary’s count property:
var bookDict: [String: String] =
["100-432112" : "Wind in the Willows",
"200-532874" : "Tale of Two Cities",
"202-546549" : "Sense and Sensibility",
"104-109834" : "Shutter Island"]
println(bookDict.count)
Accessing and Updating Dictionary Items
A specific value may be accessed or modified using key subscript syntax to reference the corresponding key. The following code references a key known to be in the bookDict dictionary and outputs the associated value (in this case the book entitled “A Tale of Two Cities”):
println(bookDict["200-532874"])
A similar approach can be used when updating the value associated with a specified key, for example, to change the title of the same book from “At Tale of Two Cities” to “Sense and Sensibility”):
bookDict["200-532874"] = "Sense and Sensibility"
The same result is also possible by making a call to the updateValue(forKey:) method, passing through the key corresponding to the value to be changed:
bookDict.updateValue("The Ruins", forKey: "200-532874")
Adding and Removing Dictionary Entries
Items may be added to a dictionary using the following key subscripting syntax:
dictionaryVariable[key] = value
For example, to add a new key-value pair entry to the books dictionary:
bookDict["300-898871"] = "The Overlook"
Removal of a key-value pair from a dictionary may be achieved either by assigning a nil value to the entry, or via a call to the removeValueForKey method of the dictionary instance. Both code lines below achieve the same result of removing the specified entry from the books dictionary:
bookDict["300-898871"] = nil
bookDict.removeValueForKey("300-898871")
Dictionary Iteration
As with arrays, it is possible to iterate through the entries by making use of the for-in looping syntax. The following code, for example, iterates through all of the entries in the books dictionary, outputting both the key and value for each entry panel:
for (bookid, title) in bookDict {
println("Book ID: \(bookid) Title: \(title)")
}
Upon execution, the following output would appear in the console:
Book ID: 100-432112 Title: Wind in the Willows Book ID: 200-532874 Title: The Ruins Book ID: 104-109834 Title: Shutter Island Book ID: 202-546549 Title: Sense and Sensibility
Summary
Collections in Swift take the form of either dictionaries or arrays. Both provide a way to collect together multiple items within a single object. Arrays provide a way to store an ordered collection of items where those items are accessed by an index value corresponding to the item position in the array. Dictionaries provide a platform for storing key-value pairs, where the key is used to gain access to the stored value. Iteration through the elements of Swift collections can be achieved using the for-in loop construct.
<google>BUY_IOS8</google>
| Previous | Table of Contents | Next |
| An Introduction to Swift Inheritance | The iOS 8 Application and Development Architecture |
