Collection Type

• array
• set
• dictionary

collection type use are generic, the type of element is specific.

Array

• With ordering.
• Access by subscript.
• Variable-length.

var someInts: [Int] = []
someInts.append(2)
someInts = []      // Empty the array

Create by class

var someDoubles = Array(repeating: 0.0, count: 3)
print(someDoubles)
var otherDoubles = Array(repeating: 2.5, count: 3)
print(otherDoubles)
var addedDoubles = someDoubles + otherDoubles    // concatenate two array into one
print(addedDoubles)

• result:

  [0.0, 0.0, 0.0]
  [2.5, 2.5, 2.5]
  [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]

Create By Array Literal

var shoppingList = ["tomato", "milk"]

// Appending
shoppingList.append("noodles")
shoppingList += ["rice"]
shoppingList += ["apple", "juice"]

// Now the array is ["tomato", "milk", "noodles", "rice", "apples", "juice"]

Accessing

print("Count of stuff: \(shoppingList.count)")  // the 'count' property is read-only.

if shoppingList.isEmpty {print("Nothing to buy.")
} else {print("Have something to buy.")
}

// Accessing
var oneStuff = shoppingList[2]  // get the "noodles"

Modifying

// Modifying
shoppingList[2] = "dumplings"
// Modifying a range of value
shoppingList[3...5] = ["pie", "cherry", "banana"] 
shoppingList[3...5] = ["pie", "cherry"]                      // it will remove the element from 3 to 5 and just insert with two new element at position 3.
//shoppingList[3...5] = ["pie", "cherry", "bread", "cookie"] the 5 is out of array's bound now, so it will trigger a run-time error.
shoppingList[3...4] = ["pie", "cherry", "peach"]             // it can work, just replace two element shoppingList[3] and shoppingList[4] with three new elenment. 
// now the array is ["tomato", "milk", "dumpings", "pie", "cherry", "peach"]

// insert(_:at:)
shoppingList.insert("drink", at: 0)
// now the shoppingList is: ["drink", "tomato", "milk", "dumpings", "pie", "cherry", "peach"]

// remove(at:)
let thing = shoppingList.remove(at: 1)
// The "thing" is assiged to be "tomato"
// Any gaps in an array are closed when an item is removed.
// So after the removing, the shoppingList is: ["drink", "milk", "dumpings", "pie", "cherry", "peach"]

let last = shoppingList.removeLast() // remove the "peach"

var str = shoppingList[0]
str.append("s")             // this will not affect the string in the shoppingList, because the String is value type, it will be copied when be passed (assigned).

shoppingList[0].append("s")// this will affect the string in the shoppingList.

// now the array is ["drinks", "milk", "dumpings", "pie", "cherry"]

Iterating Over an Array

for item in shoppingList {print(item)
}

for (i, value) in shoppingList.enumerated() {print("Item \(i): \(value)"
}
// here the 'i' is a subscript of the array.

Sets

• With no defined ordering.
• An item only appears once.

A type must be hashable in order to be stored in a set—that is, the type must provide a way to compute a hash value for itself. if two objects’hash values are equal, they are equally.

All of Swift’s basic types are hashable by default. (String, Int, Double,  Bool, Enumeration)

Create a set

• create by an Array literal

  var words: Set<Character> = ["d", "i", "v", "e"]
  print(words)
  print(words.count)

  • result

    [“d”, “i”, “e”, “v”]
    4

In a shorter form

```swift
var words: Set = ["h", "i", "d", "e"]
```

• create an instance of class Set

  var letter = Set<Character>()
  letter.insert("H")
  letter.insert("e")
  letter.insert("a")
  letter.insert("r")
  print(letter)
  print(letter.count)

  • result

    [“a”, “r”, “e”, “H”]
    4

Accessing

var words: Set = ["hide", "ice", "pink", "big"]
print(words.count)   // it's read-only
if words.isEmpty {print("words is empty.")
}

Modifying

words.insert("book")

var wordGet = words.remove("ice")  // if words doesn't contain"ice", the removing will be invalid and the wordGet will be nil.

Iterating Over a Set

for word in words {print(word)
}

Iterating in a specific order

for word in words.sorted() {print(word)
}

Set Operations

var a: Set = [1, 2, 5, 6]
var b: Set<Int> = [1, 3, 5]

var intersection = a.intersection(b)      // a & b
var difference = a.symmetricDifference(b) // !a & !b
var union = a.union(b)                    // a or b
var subtract = a.subtracting(b)           // a - b

print(intersection)
print(difference)
print(union)
print(subtract)

• result:

  [5, 1]
  [2, 6, 3]
  [3, 2, 1, 6, 5]
  [6, 2]

Membership and Equality

• ==
• isSubset(of:)
• isSuperset(of:)

• isStrictSubset(of:)

  It’s a subset but not equal to.

• isStrictSuperset(of:)

  It’s a superset but not equal to.

• isDisjoint(with:)

  Two set has no values in common. They are independent with each other.

  let all: Set = ["😂", "😎", "😺", "🙋🏼‍♂️"]
  let me: Set = ["🙋🏼‍♂️"]
  let emoj: Set = ["😂", "😎"]
  let other: Set = ["😂", "😎", "😺", "🙋🏼‍♂️"]
  print("'me' is subset of 'all': " + String(me.isSubset(of: all)))
  print("'all' is superset of 'emoj': " + String(all.isSuperset(of: emoj)))
  
  print("'all' is superset of 'other': " + String(all.isSuperset(of: other)))
  print("'all' is subset of 'other': " + String(all.isSubset(of: other)))
  print("'all' is strict superset of 'other': " + String(all.isStrictSuperset(of: other)))
  print("'all' is strict subset of 'other': " + String(all.isStrictSuperset(of: other)))
  
  print("'other' is superset of 'all': " + String(other.isSuperset(of: all)))
  print("'other' is subset of 'all': " + String(other.isSubset(of: all)))

  • result:

    ‘me’ is subset of ‘all’: true
    ‘all’ is superset of ’emoj’: true
    ‘all’ is superset of ‘other’: true
    ‘all’ is subset of ‘other’: true
    ‘all’ is strict superset of ‘other’: false
    ‘all’ is strict subset of ‘other’: false
    ‘other’ is superset of ‘all’: true
    ‘other’ is subset of ‘all’: true

Dictionary

• keys have same type, values have same type
• with no ordering
• each value is associated with a unique key
• key is unique, values may be same

Swift’s Dictionary type is bridged to Foundation’s NSDictionaryclass.
The key must conform to the Hashable protocol.

Create a dictionary

• by class

  var pet =  Dictionary<Int, String>()
  pet[11] = "dog"    // adding key-value pair
  pet[23] = "bear"

• by literal

  var pet = [11: "dog", 23: bear]

• properties

print(pet.count)
print(pet.isEmpty)

if pet[23] != nil {print(pet)
}

• result

  2
  false

Updating

pet[11] = "cat"   // update the value

if let oldValue = pet.updateValue("deer", forKey: 23) {// now the pet is: [11: "cat", 23: "deer"], and the oldValue is bear(optional).
} else {print("oldValue is nil")
}

Removing

pet[11] = nil               // remove a key-value pair.

pet.removeValue(forKey: 23) // remove a key-value pair.

pet = [11: "cat", 23: "dog"]
pet.removeAll() 
pet = [11: "cat", 23: "dog"]
pet = [:]                   // clear all

Iterating Over a Dictionary

• by key and value

  for (key, value) in pet {print("\(key): \(value)", terminator: "\t")
  }

  • result

    23: dog 11: cat

• by key or value

  var pet = [11: "cat", 23: "dog"]
  print()
  for key in pet.keys {print("\(key)", terminator: " ")
  }
  print()
  
  for value in pet.values {print("\(value)", terminator: " ")
  }

  • result

    
    11  23
    cat dog
    

Get an Array from key or value

• let keys = [Int](pet.keys)

•  let values = [String](pet.values)

• get in order by calling sorted(), the object who call the sorted should implements the Comparable.

  let keys = [Int](pet.keys.sorted())

• the pet.sorted(using:) need a Comparator to sort the dictionary.

Summary

• Creating

  • Array

    var pet: [String] = ["dog", "cat"]

  • Set

    var pet: Set<String> = ["dog", "cat"]

    var pet: Set = ["dog", "cat"]

  • Dictionary

    var pet: Dictionary<Int, String> = Dictionary<Int, String>()

    var pet = [:]

    var pet: Dictionary<Int, String> = [23: "dog", 11: "cat"]

    var pet = [23: "dog", 11: "cat"]

• Accessing and Modifying

  the Array and Dictionary can access by [someKey]directly , but the Set access by insert() and remove() .

• For-in

  • Array

    for word in words {}

  • Set

    for word in words {}

  • Dictionary

    for (key, value) in words {}

• Operation

  To generate new set, Set has some operations between two sets.