Explain collections in Swift

Following are different types of collections in Swift:

Array

Set

Dictionary

Let's understand one by one : 

1. Array

• Most common and Widely used data type. 
• Ordered collection of similar types of data. 

Declaration: 

var normalArray = [Int]() // declaring an empty                        Int array like this

• The array can be any type in swift. 
• We can also declare with some initial values. 
• Swift is a strongly typed language so we don’t have to tell the type when we declare an array but we can also specify the type

var normalArray = [2,3,4,5]
var normalArray: [Int] = [2,3,4,5]

You also can declare an array with some repeated values or using one or more arrays

var normalArray = Array(repeating: 1, count: 3) //initialize normalArray with three ones var normalArray = arrayOne + arrayTwo //initialize normalArray with addign arrayOne & arrayTwo

• Insert elements into an Array: We can insert an element at the end of the array or in a valid position.

normalArray.append(12) //append element at the end of array
normalArray += [100.0] //append at the endnormalArray.insert(12, at: 0) //insert element at 0 position. This position value should be n to n-1 if array have n number of elements.

• Access Elements of Array: We can access the element of an array using a subscript syntax, passing the index value into it. Also swift provided a list of methods to get values and check different parameters.

normalArray[2]  //return second element from array
normalArray.count  // return the number of elements in array
normalArray.isEmpty  // return false if array is empty
normalArray.capacity  // return the number of elements in arraynormalArray.first  //get the first element from array
normalArray.last  //get the last elements from array
normalArray.max()  //get the max element from array
normalArray.min()  //get the min element from arraynormalArray.sorted()  // sort the array
normalArray.reversed()  //reverse an array
normalArray.shuffled()  //shuffle the elements of an array

• Replace elements of Array: Array value can set or replace in a specific index or for a range of the index.

normalArray[2] = 1 // replace the value in second index of arraynormalArray[1...3] = [12, 23, 34] // set first to third position value as 12, 23 &34

• Remove elements from Array: Array elements can remove from different ways & different positions.

normalArray.removeAll() // remove allelement from array
normalArray.removeFirst() // remove first element from array
normalArray.removeLast() // remove last element from arraynormalArray.remove(at: 2) //remove second element from arraynormalArray.removeLast(1) // remove the second element from the end index of arraynormalArray.removeFirst(2) // remove the thirdelement from the start index of the array

• Iterate over the array: Every element of an array can be traverse using loop

for i in 0..<normalArray.count{
    print(normalArray[i])
}or
for item in normalArray{
    print(item)
}

2. Dictionary

• Can hold multiple unordered data in key-value pairs. 
• Each value is associated with a unique key and any value from the dictionary can access with the associated key with it.

• Declaration: 

var normalDictionary = [Int: String]() 
// an empty "normalDictionary" with Int type key & String type value

• The key-value pair of a dictionary can be any type in swift. 
• We can also declare with some initial values. 
• Swift is a strongly typed language so we don’t have to tell the type of key-value pair when we declare a dictionary but we can also specify the type

var normalDictionary = [1: "John", 2: "Doe"]
var normalDictionary : [Int: String] = [1: "John", 2: "Doe"]

• Insert elements into a Dictionary: We can insert a value into the dictionary using a key. If the key already exists it will replace the previous value for this key elsewhere it will add a new value.

normalDictionary[3] = "Mihalos"  // Add a value "Mihalos" for key "3"

• Access Elements of Dictionary: We can access the elements of a dictionary by using the key. Also swift provided a list of methods to get values and check different parameters.

normalDictionary[2] //return the value of second key-value pair in dictionary normalDictionary.count // return the number of elements in dictionarynormalDictionary.isEmpty  // return false if dictionary is emptynormalDictionary.capacity  // return the number of elements in dictionarynormalDictionary.first  //get the first element from dictionarynormalDictionary.max { a, b in a.value < b.value}  // return key-value pair for maximum valuenormalDictionary.min()  { a, b in a.value < b.value}  // return key-value pair for minimumvaluenormalDictionary.sorted( by: { $0.0 < $1.0 }) // reurn an sorted array of dictionarynormalDictionary.reversed()  //return key-value pair in reverse ordernormalDictionary.shuffled()  //shuffle the key-value pair of dictionary

• Replace elements from a Dictionary: A value for a key is simply replaced by putting a new value for that key. We also can use “updateValue” method to replace the value for any key. But Remember “updateValue” method returns the previous value as output.

normalDictionary[3] = "Mike"
normalDictionary.updateValue("Duke", forKey: 3)

• Remove elements from Dictionary: Dictionary elements can be removed in a different way.

normalDictionary[3] = nil  // remove key-value pair for key "3"
normalDictionary.removeAll() // remove all element from dictionary arraysimpleDictionary.removeAll(keepingCapacity: true) remove all elements with keeping the capacity or not

• Iterate over the Dictionary: Every key-value pairs of a dictionary can be traverse using loop

for (key, value) in normalDictionary {
    print(key, value)
}

Instead of key-value pair we also can access only key or value from dictionary like this

for key in normalDictionary.keys{
    print(key)
}for value in normalDictionary.values{
    print(value)
}

We also can get the keys and values of a dictionary as an array.

let keys = [Int](normalDictionary.keys)  // return all the keys as an array
let values = [String](normalDictionary.values)  //return all the values as an array

3. Set

• Set is an unordered collection of the same type of data. 
• The main characteristic of the set is, set can not have any duplicate elements.

• Declaration: You can declare an empty Int type set like this

var normalSet = Set<Int>() // an empty Int type set

• The set can be any type in swift. 
• We can also declare with some initial values. 
• Swift is a strongly typed language so we don’t have to tell the type when we declare a set but we can also specify the type

var normalSet = Set([10, 20, 30, 40, 20])
varnormalSet: Set<String> = ["John", "Doe", "Hi", "John"]

You also can declare a set with some repeated values but you will get a single value for those repeated value cause set didn’t store any duplicate element.

var normalSet = Set(repeatElement(1, count: 3)) // Initialize set with three ones but set will have only one into it.

• Insert elements into a set: We can insert an element at the end of the array or in a valid position.

normalSet.insert(12) // //append element at the end of set

• Access Elements of a set: Like array you cannot access set elements using subscript syntax but you can check an element is in the set or not. Also swift provided a list of methods to get values and check different parameters.

normalSet.contains(2)  // check an element is in the set or not
normalSet.count  // return the number of elements in set
normalSet.isEmpty  // return false if set is                       empty normalSet.capacity                     // return the number of elements in setnormalSet.first  //get the first element from set
normalSet.max()  //get the max element from set
normalSet.min()  //get the min element from setnormalSet.sorted()  // sort the set
normalSet.reversed()  // reverse set
normalSet.shuffled() // shuffle set elements

• Remove elements: Set elements can remove from different way & from different positions also.

normalSet.removeFirst() // remove first element from set
normalSet.remove(1)  // remove from a specific indexnormalSet.removeAll()  // remove all elements from set
normalSet.removeAll(keepingCapacity: true)  // remove all elements with keeping the capacity or not

• Iterate over the set: Every element of a set can be traverse using loop

for data in normalSet {
    print(data)
}

The set type didn’t have any order so if you want to traverse in any order you can do it by swift provided methods

for data in normalSet.sorted() {
    print(data)
}for data in normalSet.reversed() {
    print(data)
}

• Different set operations: You also can perform different set operations within two sets and each of those operations will create a new set.

normalSet2.union(normalSet3).sorted()  // perform union opertion within normalSet2 & normalSet3
normalSet2.intersection(normalSet3) // perform intersection within two set
normalSet2.subtracting(normalSet3)  // perform subtracting
normalSet2.symmetricDifference(normalSet3)  // perform symmetricDifferencenormalSet2.isSubset(of: normalSet3)  // check one set is subset of snother or not 
normalSet2.isSuperset(of: normalSet3)  // check superset or not 
normalSet2.isDisjoint(with: normalSet3)  // check disjoint or not

There are some more interview questions answers for collections in this site. Visit here