Dictionary in Swift: Top 20 Interview Questions

Dictionary in Swift:

Q.1 What is a dictionary in Swift?

Ans. A dictionary in Swift is a collection type that stores key-value pairs. Each value in the dictionary is associated with a unique key, and you can use the key to retrieve the corresponding value.

Dictionaries in Swift are unordered collections, meaning the order of elements is not guaranteed.

Example: 

//Simple example of how to use a dictionary in swift
var dictionaryName = [
  "Key1": "Value1",
  "Key2": "Value2",
  "Key3": "Value3"
]

Every key in a dictionary is unique.

One of the fundamental properties of a dictionary in Swift is that each key must be unique within the dictionary. This uniqueness ensures that you can use a key to uniquely identify and access its associated value. If you try to insert a new value with an existing key, it will overwrite the existing value.

Q.2 How to create a dictionary in Swift?

Ans. Here’s a basic example of how you can create a dictionary in Swift or declare dictionary in Swift:

Creating an empty dictionary:

An empty dictionary in Swift is a dictionary that contains no key-value pairs. Initializing an empty dictionary can be done in a few different ways, and the choice is often a matter of personal preference or specific requirements.

Here are a few ways to initialize an empty dictionary in Swift:

1. Using the initializer syntax with an empty dictionary literal:

var emptyDictLiteral: [String: Int] = [String: Int]()

2. Using the Dictionary initializer:

var emptyDictInit = Dictionary<String, Int>()

3. Using the type annotation with an empty dictionary literal:

var emptyDictTypeAnnotation: [String: Int] = [:]

Creating a dictionary with initial values

Creating a dictionary with initial values in Swift is straightforward. You can use the dictionary literal syntax, which involves placing a list of key-value pairs inside square brackets. Here’s an example:

// Creating a dictionary with initial values
var fruitPrices = ["Apple": 2, "Banana": 1, "Orange": 3]

If you want to specify the types explicitly, you can use the following syntax:

// Creating a dictionary with explicit types
var fruitPrices: [String: Int] = ["Apple": 2, "Banana": 1, "Orange": 3]

Creating a dictionary with default values

In Swift, when you attempt to retrieve a value from a dictionary using a key that doesn’t exist, Swift returns nil by default. However, if you want to provide a default value to be used when accessing a missing key, Swift offers convenient ways to achieve this.
you can achieve default values for dictionary keys by using the nil-coalescing operator (??) or by using the default property introduced in Swift 4.0. Here are examples of both approaches:

Using Nil-Coalescing Operator (??):-

var myDict = ["key1": 42, "key2": 99]

// Access a key with default value if it doesn't exist
let value = myDict["key3"] ?? 0

print(value) // Outputs: 0

// Access an existing key
let existingValue = myDict["key1"] ?? 0

print(existingValue) // Outputs: 42

In this example, if the key “key3” does not exist in the dictionary, the nil-coalescing operator provides a default value of 0.

Using default property:-

var myDict = ["key1": 42, "key2": 99] 

// Access a key with default value if it doesn't exist 
let value = myDict["key3", default: 0] 
print(value) // Outputs: 0 

// Access an existing key 
let existingValue = myDict["key1", default: 0] 
print(existingValue) // Outputs: 42

Starting from Swift 4.0, you can use the default property to specify a default value for a dictionary key.

Q.3 How to access a value in dictionary swift?

Ans. Accessing a value in a dictionary in Swift is done using the subscript syntax. You use the key inside square brackets to access the corresponding value.

Here’s an example:

// Creating a dictionary with initial values
var fruitPrices = ["Apple": 2, "Banana": 1, "Orange": 3]

// Accessing values using keys
let applePrice = fruitPrices["Apple"] // applePrice is an optional Int

// Checking if the value is present
if let price = applePrice {
print("The price of Apple is $\(price)")
} else {
print("Apple not found in the dictionary")
}

In this example, fruitPrices["Apple"] retrieves the value associated with the key “Apple” from the fruitPrices dictionary. Since the subscript operation returns an optional type (Int? in this case), it’s a good practice to use optional binding (e.g., if let or guard let) to safely unwrap and use the value.

If the key is not present in the dictionary, the subscript operation will return nil, which you can handle accordingly.

Access Keys Only:

If you want to access only the keys of a dictionary in Swift, you can use the keys property. Here’s an example:

// Creating a dictionary with initial values
var fruitPrices = ["Apple": 2, "Banana": 1, "Orange": 3]

// Accessing keys only
let keys = fruitPrices.keys

print("Keys: ", keys)

Output:

Keys:  ["Apple", "Orange", "Banana"]

 Access Values Only:

If you want to access only the values of a dictionary in Swift, you can use the values property. Here’s an example:

// Creating a dictionary with initial values
var fruitPrices = ["Apple": 2, "Banana": 1, "Orange": 3]

// Accessing values only
let values = fruitPrices.values

print("Values: ", values)

Output:

Values:  [3, 2, 1]

In this example, fruitPrices.values returns a collection of all values in the fruitPrices dictionary

Keep in mind that the order of values in the values collection is not guaranteed to be in any specific order. If you need the values in a specific order, you might want to create an array of values and sort them accordingly.

Q.4 How to add element to a dictionary?

Ans. You can add a new key-value pair to a dictionary in Swift by using the subscript syntax or the updateValue(_:forKey:) method.

Here are examples of both approaches:

Using Subscript Syntax:

// Creating an empty dictionary
var fruitPrices = [String: Int]()

// Adding a new key-value pair
fruitPrices["Grapes"] = 4

In this example, a new key-value pair with the key “Grapes” and the value 4 is added to the fruitPrices dictionary.

Using updateValue(_:forKey:) Method:

// Creating an empty dictionary
var fruitPrices = [String: Int]()

// Adding a new key-value pair using updateValue(_:forKey:)
fruitPrices.updateValue(4, forKey: "Grapes")

This method not only adds a new key-value pair but also returns the old value associated with the key (or nil if the key was not present). This can be useful if you need to perform additional logic based on whether the key already existed.

Q.5 How to remove an element from a Dictionary?

Ans. In Swift, you can remove an element (key-value pair) from a dictionary using the removeValue(forKey:) method or by assigning nil to the key using subscript notation.

Here are examples of both approaches:

Using removeValue(forKey:) Method:

// Creating a dictionary with initial values
var fruitPrices = ["Apple": 2, "Banana": 1, "Orange": 3]

// Removing a key-value pair using removeValue(forKey:)
let removedPrice = fruitPrices.removeValue(forKey: "Banana")

// Check if the removal was successful
if let removedPrice = removedPrice {
    print("Removed price for Banana: $\(removedPrice)")
} else {
    print("Banana not found in the dictionary")
}

// Print the updated dictionary
print(fruitPrices)

Output:

Removed price for Banana: $1
["Orange": 3, "Apple": 2]

In this example, removeValue(forKey:) removes the key-value pair with the specified key (“Banana”) from the dictionary and returns the removed value. If the key is not present, it returns nil.

Assigning nil using Subscript Notation:

// Creating a dictionary with initial values
var fruitPrices = ["Apple": 2, "Banana": 1, "Orange": 3]

// Removing a key-value pair by assigning nil
fruitPrices["Banana"] = nil

// Print the updated dictionary
print(fruitPrices)

Output:

["Apple": 2, "Orange": 3]

In this example, assigning nil to the key “Banana” effectively removes the key-value pair from the dictionary.

Remove all the values in a dictionary:

To remove all values from a dictionary in Swift, you can use the removeAll() method.

Here’s an example:

// Creating a dictionary with initial values
var fruitPrices = ["Apple": 2, "Banana": 1, "Orange": 3]

// Removing all values from the dictionary
fruitPrices.removeAll()

// Print the updated dictionary (it will be empty)
print(fruitPrices)

Output:

[:]

After calling removeAll(), the dictionary will be empty, and any existing key-value pairs will be removed.

Q.6 How to update Value of Dictionary?

Ans. To update the value of a specific key in a dictionary in Swift, you can use the subscript syntax.

Here’s an example:

// Creating a dictionary with initial values
var fruitPrices = ["Apple": 2, "Banana": 1, "Orange": 3]

// Updating the value for the key "Banana"
fruitPrices["Banana"] = 2

// Print the updated dictionary
print(fruitPrices)

Output:

["Orange": 3, "Banana": 2, "Apple": 2]

In this example, the value for the key “Banana” is updated to 2. If the key “Banana” already exists, the associated value is modified. If the key doesn’t exist, a new key-value pair is added to the dictionary.

You can also use the updateValue(_:forKey:) method to update a value and get the previous value if it existed:

// Creating a dictionary with initial values
var fruitPrices = ["Apple": 2, "Banana": 1, "Orange": 3]

// Updating the value for the key "Banana" using updateValue(_:forKey:)
if let previousValue = fruitPrices.updateValue(2, forKey: "Banana") {
    print("Previous value for Banana was \(previousValue)")
} else {
    print("Banana not found in the dictionary")
}

// Print the updated dictionary
print(fruitPrices)

Output:

Previous value for Banana was 1
["Banana": 2, "Orange": 3, "Apple": 2]

In this example, the updateValue(_:forKey:) method updates the value for the key “Banana” to 2 and returns the previous value if it existed. If the key doesn’t exist, it returns nil. Use optional binding (as shown in the example) to check if the update was successful and to access the previous value.

Q.7 How to iterating Over a Dictionary in Swift?

Ans. To iterate over a dictionary in Swift, you can use a for-in loop.

Here’s an example:

// Creating a dictionary with initial values
var fruitPrices = ["Apple": 2, "Banana": 1, "Orange": 3]

// Iterating over the dictionary using a for-in loop
for (fruit, price) in fruitPrices {
    print("\(fruit): $\(price)")
}

Output:

Banana: $1
Orange: $3
Apple: $2

In this example, the for (fruit, price) in fruitPrices loop iterates over each key-value pair in the fruitPrices dictionary. The loop binds the key to the constant variable fruit and the value to the constant variable price. You can then use these variables within the loop body.

If you only need the keys or values, you can iterate over the keys or values property:

// Iterating over keys 
for fruit in fruitPrices.keys {    
    print("Fruit: \(fruit)") 
} 

// Iterating over values 
for price in fruitPrices.values {     
    print("Price: $\(price)") 
}

These iterations allow you to access either the keys or the values individually.

Q. 8 How to find number of dictionary elements?

Ans. You can find the number of elements (key-value pairs) in a dictionary in Swift using the count property. The count property returns an integer representing the number of elements in the dictionary.

Here’s an example:

// Creating a dictionary with initial values
var fruitPrices = ["Apple": 2, "Banana": 1, "Orange": 3]

// Finding the number of elements in the dictionary
let numberOfElements = fruitPrices.count

// Printing the result
print("Number of elements in the dictionary: \(numberOfElements)")

Output:

Number of elements in the dictionary: 3

In this example, fruitPrices.count will give you the count of elements in the fruitPrices dictionary. The result is then printed or can be used as needed in your code.

Q.9 How to check empty dictionary?

Ans. You can check if a dictionary is empty in Swift using the isEmpty property. The isEmpty property returns true if the dictionary contains no elements (i.e., it’s empty), and false otherwise.

Here’s an example:

// Creating a dictionary with initial values
var fruitPrices = ["Apple": 2, "Banana": 1, "Orange": 3]

// Checking if the dictionary is empty
if fruitPrices.isEmpty {
    print("The dictionary is empty.")
} else {
    print("The dictionary is not empty.")
}

Output:

The dictionary is not empty.

In this example, fruitPrices.isEmpty checks whether the dictionary is empty or not. If the dictionary is empty, it prints a message indicating that. Otherwise, it prints a message indicating that the dictionary is not empty.

Q.10 How to apply a filter to a dictionary in swift?

Ans. You can apply a filter to a dictionary in Swift using the filter method. The filter method creates a new dictionary containing only the key-value pairs that satisfy a given condition.

Here’s an example of applying a filter to a dictionary based on a condition:

// Creating a dictionary with initial values
var fruitPrices: [String: Int] = ["Apple": 2, "Banana": 1, "Orange": 3, "Grapes": 4]

// Applying a filter to the dictionary
let expensiveFruits = fruitPrices.filter { $0.value > 2 }

// Printing the filtered dictionary
print("Expensive fruits: \(expensiveFruits)")

Output:

Expensive fruits: ["Orange": 3, "Grapes": 4]

In this example, the filter method is used to create a new dictionary called expensiveFruits that includes only the key-value pairs where the value is greater than 2. The condition $0.value > 2 is a closure that takes each key-value pair ($0) and checks if the value is greater than 2.

You can customize the filter condition based on your specific requirements. The resulting dictionary will only include the key-value pairs that satisfy the given condition.

Q.11 Difference between array and dictionary in swift

Ans. Arrays and dictionaries are both collection types in Swift, but they serve different purposes and have distinct characteristics. Here are some key differences between arrays and dictionaries:

1. Ordered vs. Unordered:
   • Array: Elements in an array are ordered and have indices, starting from zero. The order of elements is preserved.
   • Dictionary: Elements in a dictionary are unordered. There is no guaranteed order of key-value pairs.
2. Element Access:
   • Array: Elements in an array are accessed using their index.

     let myArray = [1, 2, 3]

     let elementAtIndex = myArray[1] // Accessing the element at index 1
     

   • Dictionary: Elements in a dictionary are accessed using keys.

     let myDictionary = ["Key1": "Value1", "Key2": "Value2"]

     let valueForKey = myDictionary["Key1"] // Accessing the value for "Key1"
     

3. Type of Elements:
   • Array: Contains an ordered list of elements of the same type.
   • Dictionary: Contains an unordered collection of key-value pairs, where keys and values can have different types.
4. Mutability:
   • Array: Can be both mutable and immutable. You can create mutable arrays using var and immutable arrays using let.
     var mutableArray = [1, 2, 3]

     let immutableArray = [1, 2, 3]
     

   • Dictionary: Similarly, dictionaries can be mutable or immutable.
     var mutableDictionary = ["Key1": "Value1", "Key2": "Value2"]

     let immutableDictionary = ["Key1": "Value1", "Key2": "Value2"]
     

5. Use Cases:
   • Array: Used when you have an ordered collection of elements and you need to access elements by their index.
   • Dictionary: Used when you have a set of key-value pairs, and you need to access values based on their associated keys.

Here’s a simple summary:

• Array: Ordered list of elements.
• Dictionary: Unordered collection of key-value pairs.

Q12. Are dictionary slow in swift?

Ans. The performance of dictionaries in Swift, is generally efficient. Dictionaries in Swift are implemented as hash tables, which provides fast average-case time complexity for common operations such as inserting, deleting, and looking up values. The average-case time complexity for these operations is O(1).

However, it’s important to note a few considerations:

1. Hashing Collisions: Dictionaries use a hash function to map keys to indices in the underlying data structure. In rare cases, multiple keys may produce the same hash value, leading to a collision. Swift dictionaries handle collisions using techniques like separate chaining to maintain performance.
2. Worst-Case Scenarios: While the average-case time complexity is O(1), in worst-case scenarios (e.g., due to many collisions), the performance might degrade to O(n), where n is the number of elements. This is an edge case and is uncommon in practice.
3. Size Matters: The efficiency of dictionary operations can be affected by the size of the dictionary. As the number of elements increases, there might be more hash collisions, potentially impacting performance.
4. Key Types: The type of keys used in a dictionary can influence performance. Simple types like integers or strings generally work well, but complex or poorly-distributed hash functions might lead to more collisions.

In most scenarios, dictionaries in Swift provide fast and efficient access to values based on keys. If you have specific concerns about performance, you might want to profile your code using Instruments or other profiling tools to identify bottlenecks and optimize accordingly.

Q.13 Can you add a class to a dictionary in swift?

Ans. Yes, you can add instances of a class to a dictionary in Swift. Dictionaries in Swift are flexible and can store values of any type, including instances of custom classes.

Here’s a simple example:

// Define a custom class
class Fruit {
    var name: String
    var price: Double

    init(name: String, price: Double) {
        self.name = name
        self.price = price
    }
}

// Create instances of the Fruit class
let apple = Fruit(name: "Apple", price: 2.0)
let banana = Fruit(name: "Banana", price: 1.0)

// Create a dictionary and add instances of the Fruit class
var fruitDictionary: [String: Fruit] = [:]

fruitDictionary["Apple"] = apple
fruitDictionary["Banana"] = banana

// Accessing values from the dictionary
if let appleInDictionary = fruitDictionary["Apple"] {
    print("Name: \(appleInDictionary.name), Price: \(appleInDictionary.price)")
} else {
    print("Apple not found in the dictionary")
}

Output:

Name: Apple, Price: 2.0

In this example, a custom class Fruit is defined with properties name and price. Instances of this class (apple and banana) are then added to a dictionary (fruitDictionary) using string keys.

You can use any type as the value in a dictionary, including other classes, structs, enums, or basic types.

Q.14  Convert dictionary to json in swift?

Ans. In Swift, you can convert a dictionary to JSON format using the JSONSerialization class.

Here’s an example:

import Foundation

// Define a dictionary
let fruitPrices = ["Apple": 2, "Banana": 1, "Orange": 3]

// Convert the dictionary to JSON data
do {
     let jsonData = try JSONSerialization.data(withJSONObject: fruitPrices, options: .prettyPrinted)

    // Convert JSON data to a String for printing or further use
    if let jsonString = String(data: jsonData, encoding: .utf8) {
        print("JSON representation of the dictionary:")
        print(jsonString)
    }
} catch {
    print("Error converting dictionary to JSON: \(error)")
}

Output:

JSON representation of the dictionary:
{
  "Apple" : 2,
  "Orange" : 3,
  "Banana" : 1
}

In this example:

1. The JSONSerialization.data(withJSONObject:options:) method is used to convert the fruitPrices dictionary to JSON data. The options parameter with the .prettyPrinted option is used to create a more human-readable JSON format.
2. The resulting JSON data can then be converted to a string using String(data:encoding:) for printing or further processing.

Q.15 how to compare two dictionary in swift?

Ans. In Swift, you can compare dictionaries using the equality operator (==) to check if they are equal. Two dictionaries are considered equal if they contain the same key-value pairs, regardless of the order of the pairs.

Here’s an example:

let dict1 = ["Apple": 2, "Banana": 1, "Orange": 3]
let dict2 = ["Apple": 2, "Orange": 3, "Banana": 1]

if dict1 == dict2 {
    print("The dictionaries are equal.")
} else {
    print("The dictionaries are not equal.")
}

In this example, dict1 and dict2 are considered equal because they contain the same key-value pairs.

Q.16 Merging two dictionary in swift?

Ans. In Swift, you can merge two dictionaries using the merging(_:uniquingKeysWith:) method. This method creates a new dictionary that contains the key-value pairs from both dictionaries. If there are common keys, the uniquingKeysWith closure allows you to specify how to resolve conflicts.

Here’s an example:

// Define two dictionaries
let dict1 = ["Apple": 2, "Banana": 1, "Orange": 3]
let dict2 = ["Banana": 4, "Grapes": 5, "Kiwi": 6]

// Merge dictionaries, resolving conflicts by choosing the maximum value
let mergedDict = dict1.merging(dict2) { (current, new) in
    return max(current, new)
}

print("Merged Dictionary:")
print(mergedDict)

Output:

Merged Dictionary:
["Kiwi": 6, "Orange": 3, "Grapes": 5, "Apple": 2, "Banana": 4]

In this example, the mergedDict will contain the key-value pairs from both dict1 and dict2. If there are common keys, the closure { (current, new) in return max(current, new) } is used to choose the maximum value for those keys.

You can customize the closure based on your specific needs for resolving conflicts. The merging(_:uniquingKeysWith:) method is a flexible way to merge dictionaries while providing control over how to handle overlapping keys.

Q.17 Can dictionary have two duplicate keys in swift?

Ans. No, dictionaries in Swift cannot have two duplicate keys. Each key in a dictionary must be unique. If you attempt to insert a key-value pair into a dictionary with a key that already exists, the new value will overwrite the existing value associated with that key.

Here’s an example:

var myDictionary = ["Apple": 2, "Banana": 1, "Orange": 3]

// Attempting to insert a duplicate key
myDictionary["Apple"] = 5

print(myDictionary)

Output:

["Apple": 5, "Orange": 3, "Banana": 1]

In this example, the value associated with the key “Apple” is updated to 5. There are no duplicate keys; the new value simply replaces the existing one.

Swift dictionaries enforce the uniqueness of keys to ensure a one-to-one mapping between keys and values.

Q.18 What is contains(where:) property in  dictionary swift?

Ans. In Swift, you can use the contains(where:) method to check if a specific condition is met by any key-value pair in a dictionary. This method takes a closure that specifies the condition, and it returns true if at least one key-value pair satisfies that condition.

Here’s an example of using contains(where:):

Example-1

// Creating a dictionary with initial values
var fruitPrices = ["Apple": 2, "Banana": 1, "Orange": 3]

// Checking if the dictionary contains a specific key-value pair
let containsBanana = fruitPrices.contains { (key, value) in
    return key == "Banana" && value == 1
}

if containsBanana {
    print("The dictionary contains the key-value pair for Banana: \(fruitPrices["Banana"]!)")
} else {
    print("The dictionary does not contain the key-value pair for Banana")
}

In this example, containsBanana is a Boolean variable that indicates whether the dictionary contains the key-value pair where the key is “Banana” and the value is 1. The closure checks for this condition, and if it’s true, the dictionary contains the specified key-value pair.

Example-2

Checking for Key or Value Existence:

var fruits = ["Apple": 2, "Banana": 1, "Orange": 3]

let containsFruitsKey = fruits.contains { $0.key == "Apple" }
let containsFruitsValue = fruits.contains { $0.value == 1 }

print(containsFruitsKey)
print(containsFruitsValue)

Output:

true
true

This code will print true for containsFruitsKey because the key “Apple” is present in the dictionary, and it will print true for containsFruitsValue because the value 1 is present in the dictionary. If either key or value were not present, the corresponding variable would be false.

Read More:

https://developer.apple.com/documentation/swift/dictionary

Top iOS Interview Questions and Answers