Collections in Apex: Lists, Sets, and Maps

In Apex programming, collections are like containers that help you store and manage multiple pieces of data. They’re like the different types of boxes you might use to organize your belongings. The three main types of collections in Apex are Lists, Sets, and Maps, and each has its own unique characteristics and use cases.

Lists:

Think of a List in Apex as a simple ordered container, much like a to-do list. You can add items to a List, and they maintain their order. It’s like writing tasks on sticky notes and putting them in a line. Lists are useful when you want to work with a collection of items and need to keep them in a specific sequence.

List<String> shoppingList = new List<String>();
shoppingList.add('Apples');
shoppingList.add('Bananas');
shoppingList.add('Milk');

Check out these Ultimate Salesforce interview questions and answers for extensive knowledge and informative details about Salesforce Admin, Developer, Integration, and LWC modules.

Sets:

Sets are a bit different. They are like a collection of unique keys, just like a set of keys you might have for different doors. Sets automatically remove duplicate values, so you won’t have the same item more than once. They are great for maintaining a list of unique elements.

Set<String> uniqueNames = new Set<String>();
uniqueNames.add('John');
uniqueNames.add('Alice');
uniqueNames.add('John'); // Won't be added again, as it's a duplicate.

Collection is one of the important concept, checkout: Collections in Salesforce Apex

Maps:

Maps are like dictionaries where you have a key and a value associated with it. Think of it as a phone book where a name (the key) corresponds to a phone number (the value). Maps are used to store and quickly retrieve data based on a unique identifier.

Map<String, Integer> ageMap = new Map<String, Integer>();
ageMap.put('John', 30);
ageMap.put('Alice', 25);

Collections in Apex are incredibly handy when you need to work with multiple pieces of data together. Lists maintain order, Sets ensure uniqueness, and Maps allow for efficient data retrieval. Choosing the right type of collection depends on your specific needs in your Apex code. These collection types help you organize and manipulate data efficiently, making them valuable tools in Salesforce development. As you become more proficient in Apex, you’ll find yourself using collections frequently to handle complex data scenarios in your applications.

You can explore all the String methods in Apex, and learn those examples for each method.

Frequently Asked Questions (FAQs)

1.What is the difference between Map, Set, and List in Apex?

In Apex, a Map, Set, and List are different types of collections used to store and manage data.

• Map: A Map is a collection of key-value pairs where each unique key maps to a single value. Keys and values can be of any data type, and you can use methods like put, get, and containsKey to interact with the Map. Maps are particularly useful when you need to quickly look up values based on a unique key.
• Set: A Set is a collection of unique elements without any duplicates. Sets do not maintain the order of elements and are useful when you need to store a collection of unique items. Common methods include add, remove, and contains.
• List: A List is an ordered collection of elements that can contain duplicates. Lists maintain the order of insertion and allow for indexed access to elements. Lists are ideal for scenarios where the order of elements matters, and common methods include add, get, and remove.

2.What are the different types of collections in Apex?

In Apex, there are three primary types of collections:

1. List: An ordered collection of elements that can contain duplicates. Elements can be accessed by their index position. Lists are useful when the order of elements is important.
2. Set: An unordered collection of unique elements. Sets do not allow duplicates and do not maintain any specific order. They are useful for storing distinct items and ensuring no duplicates.
3. Map: A collection of key-value pairs where each unique key maps to a single value. Maps are useful for quickly retrieving values based on unique keys.

These collections are powerful tools for managing and manipulating groups of related data in Apex.

3.What is Map collection in Apex?

A Map collection in Apex is a collection type that stores key-value pairs, where each unique key maps to a specific value. The keys and values can be of any data type, including primitive types, collections, or user-defined types. Maps are highly efficient for scenarios where you need to associate unique identifiers with specific values and quickly look up those values. Common methods for interacting with a Map include:

• put(key, value): Adds a key-value pair to the Map.
• get(key): Retrieves the value associated with a given key.
• containsKey(key): Checks if the Map contains a specific key.
• remove(key): Removes the key-value pair for a given key from the Map.

Maps are especially useful for scenarios like caching data, maintaining dictionaries, or performing quick lookups.

4.What is the difference between Map and Set in Salesforce?

The primary difference between a Map and a Set in Salesforce (Apex) lies in their structure and use cases:

• Map: A Map is a collection of key-value pairs where each unique key is associated with a single value. Maps are used when you need to maintain a relationship between keys and values and perform quick lookups based on unique keys. For example, storing and retrieving configuration settings by name or user records by their unique IDs.
• Set: A Set is a collection of unique elements without any duplicates. Sets are used when you need to ensure that a collection contains no repeated items and when the order of elements is not important. Sets are ideal for scenarios such as maintaining a list of unique identifiers or filtering out duplicates from a collection of items.

5.How do you add multiple elements to a List in Apex?

You can add multiple elements to a List either during initialization or dynamically using the addAll() method. The addAll() method appends all elements from another List or Set to the current List. This is useful when you want to merge multiple collections into a single List, especially when handling dynamic datasets or working with user inputs.

Snippet:

List<String> cities = new List<String>{'New York', 'Paris'};
List<String> newCities = new List<String>{'Tokyo', 'London'};
cities.addAll(newCities);
System.debug(cities);  // Output: (New York, Paris, Tokyo, London)

The addAll() method allows you to add multiple elements to a List at once, making it easier to manage large data sets or combine several Lists into one. This method is a quick and efficient way to append items without having to add them individually.

6.How can you remove duplicates from a List in Apex?

Lists in Apex allow duplicate values, so to remove duplicates, you can convert the List to a Set (which enforces uniqueness) and then back to a List. This approach ensures all duplicate elements are filtered out, giving you a List with only unique elements. It’s often used when working with raw data where duplicates can occur.

Snippet:

List<String> cities = new List<String>{'New York', 'Paris', 'Tokyo', 'Paris'};
Set<String> uniqueCities = new Set<String>(cities);  // Remove duplicates
cities = new List<String>(uniqueCities);  // Convert back to List
System.debug(cities);  // Output: (New York, Paris, Tokyo)

By converting a List to a Set and back, you remove duplicate entries from the List. This method is ideal when working with unfiltered or duplicate-prone data and allows you to retain only the unique values without changing the order of the collection significantly.

7.How do you check if a Map contains a specific key?

Meaning:
The containsKey() method in a Map checks whether a specific key is present. This method returns a Boolean value (true or false) and is particularly useful when working with dynamic data where you need to verify whether a key exists before attempting to access or modify its associated value.

Snippet:

Map<Integer, String> cityMap = new Map<Integer, String>{1 => 'New York', 2 => 'Paris'};
if (cityMap.containsKey(1)) {
    System.debug('Key 1 exists in the map.');
} else {
    System.debug('Key 1 does not exist.');
}

The containsKey() method is essential for safely checking if a key is present in a Map before performing any operations on it. This prevents errors such as attempting to access or update values for non-existent keys, which could result in exceptions.

8.How can you remove elements from a Set in Apex?

Meaning:
Sets allow removal of specific elements using the remove() method, which deletes a single element from the Set if it exists. Additionally, you can remove all elements at once using the clear() method. These methods are useful when managing dynamic data that requires selective or complete removal of elements from the Set.

Snippet

Set<String> cities = new Set<String>{'New York', 'Paris', 'Tokyo'};
cities.remove('Paris');  // Remove a specific element
System.debug(cities);  // Output: {New York, Tokyo}

The remove() method is used for deleting specific elements from a Set, while clear() can remove all elements at once. These methods are useful when updating or cleaning up data in real-time, especially when elements are no longer needed.

9.How do you merge two Maps in Apex?

The putAll() method allows merging two Maps by adding all key-value pairs from one Map to another. If both Maps have the same key, the value from the second Map will overwrite the value in the first. This is commonly used when updating or combining datasets that share common keys but have different values.

Snippet:

Map<Integer, String> cityMap1 = new Map<Integer, String>{1 => 'New York', 2 => 'Paris'};
Map<Integer, String> cityMap2 = new Map<Integer, String>{3 => 'Tokyo', 2 => 'London'};
cityMap1.putAll(cityMap2);
System.debug(cityMap1);  // Output: {1 => New York, 2 => London, 3 => Tokyo}

The putAll() method is efficient for merging two Maps, especially when you need to update existing key-value pairs or add new entries. If the same key exists in both Maps, the method ensures that the value in the target Map gets updated with the value from the source Map.

10.Converting List to Set

You can convert a List to a Set to automatically remove any duplicate values in the List. This can be useful if the List initially allows duplicates, but you need to ensure uniqueness after data processing. The Set will contain only unique elements.

Snippet

List<String> cities = new List<String>{'New York', 'Paris', 'Tokyo', 'New York'};
Set<String> uniqueCities = new Set<String>(cities);
System.debug(uniqueCities);  // Output: {New York, Paris, Tokyo}

By converting a List to a Set, you ensure that all duplicates are removed, which is useful when the data needs to be unique. Once converted to a Set, you can iterate or further manipulate the data.

CRS Info Solutions offers a state-of-the-art, hands-on Salesforce course for beginners, providing comprehensive practical training for both admin and developer roles. You’ll gain extensive hands-on experience through live, instructor-led sessions, ensuring you master real-world skills. Enroll for a demo now and kickstart your Salesforce journey with expert guidance.