What is a Map class in Salesforce Apex? with examples

Table of Contents

• What is a Map class?
• Map Class Methods
• Code Examples
• Best practices
• Common Mistakes
• Real-world examples

In Salesforce, a Map is a collection of key-value pairs where each unique key maps to a single value. It’s a fundamental data structure used to store and manipulate data efficiently.

What is a Map class in Salesforce Apex?

In Salesforce Apex, the Map class is a collection type that stores unique keys paired with values. It is used to quickly retrieve, update, or delete data based on a unique identifier, making data handling more efficient and faster than using lists, especially with large data sets.

Our  Salesforce course at CRS Info Solutions provides real-time, job-oriented training, and comprehensive certification exam preparation. Sign up for a free demo today to start your journey towards Salesforce expertise.

The keys in a Map must be unique and are used to access the corresponding values. Apex provides several methods to manipulate these entries, such as put(), get(), and remove(), offering developers powerful tools to manage data effectively within their applications.

See also: Strings in Salesforce Apex

Map Class Methods in Salesforce Apex

put()

The put() method in the Map class is used to add a new key-value pair to the map or update the value of an existing key. When a new key is provided, put() adds the key along with its corresponding value to the map. If the key already exists, the method updates the associated value with the new value provided. This functionality makes put() essential for maintaining an accurate and current representation of data within the map.

Map<String, Integer> myMap = new Map<String, Integer>();
myMap.put('John', 100);
myMap.put('Jane', 200);
System.debug(myMap); // Output: {John=100, Jane=200}

This code initializes a new map myMap with keys of type String and values of type Integer. It then adds two key-value pairs to the map: 'John' with a value of 100 and 'Jane' with a value of 200. The System.debug statement outputs the contents of the map.

Hyderabad has emerged as a thriving tech city, attracting global corporations and fostering a high demand for skilled professionals. Salesforce is one of the most sought-after skills due to its crucial role in CRM and business management. Opting for our job-oriented Salesforce training in Hyderabad offers a significant edge, as the city’s robust job market is consistently growing. Enroll for demo today!

get()

The get() method retrieves the value associated with a specific key from the map. If the key exists in the map, get() returns the corresponding value. If the key does not exist, the method returns null. This method is particularly useful for accessing elements in the map efficiently, allowing quick data retrieval without the need to iterate over the entire collection.

Integer score = myMap.get('John');
System.debug(score); // Output: 100

This code retrieves the value associated with the key 'John' from the myMap map and stores it in the score variable. The System.debug statement outputs the value, which is 100.

Checkout: DML statements in Salesforce

remove()

The remove() method is used to delete a key and its associated value from the map. When a key is passed to remove(), the method eliminates the key-value pair from the map and returns the value that was associated with the key. If the key does not exist, it returns null. This method is crucial for managing the contents of the map, allowing for the dynamic removal of entries as needed.

myMap.remove('Jane');
System.debug(myMap); // Output: {John=100}

This code removes the key-value pair with the key 'Jane' from the myMap map. The System.debug statement outputs the contents of the map after removal, showing only the remaining key-value pair {John=100}.

See also: SOQL Query in Salesforce

keySet()

keySet() provides a set of all keys contained in the map. This method is invaluable when you need to iterate over each key in the map. The returned set can be used in loops for accessing each key, which can then be used to retrieve corresponding values or perform other operations. keySet() helps in scenarios where operations need to be performed on all keys, or a subset of them, efficiently.

Set<String> keys = myMap.keySet();
System.debug(keys); // Output: {John}

This code retrieves a set of all the keys in the myMap map and stores it in the keys variable. The System.debug statement outputs the set of keys, which is {John}.

See also: Arrays in Salesforce Apex

values()

The values() method returns a collection of all the values stored in the map. This collection is useful when only the values are needed, irrespective of the keys. For instance, if one needs to process or manipulate every stored value, values() provides a direct way to access these elements without dealing with their associated keys.

List<Integer> values = myMap.values();
System.debug(values); // Output: (100)

This code retrieves a list of all the values in the myMap map and stores it in the values variable. The System.debug statement outputs the list of values, which is (100).

See also: collections in Salesforce Apex

clear()

clear() completely empties the map of all its key-value pairs, effectively resetting the map. This method is particularly useful when you need to discard all entries in a map without replacing it with a new map object. It ensures that the map contains no entries, which is helpful in scenarios requiring a fresh start with the data structure.

myMap.clear();
System.debug(myMap); // Output: {}

This code removes all the key-value pairs from the myMap map. The System.debug statement outputs the contents of the map after clearing, showing an empty map {}.

See also: Classes in Salesforce Apex

containsKey()

containsKey() checks whether a specific key exists within the map. This method returns a boolean value: true if the map contains the specified key, otherwise false. It is a straightforward way to verify the presence of a key in the map before attempting operations that depend on the existence of that key, thus avoiding errors related to non-existent keys.

myMap.put('Alice', 300);
Boolean hasKey = myMap.containsKey('Alice');
System.debug(hasKey); // Output: true

This code adds a new key-value pair 'Alice' with a value of 300 to the myMap map. It then checks if the key 'Alice' exists in the map using the containsKey method and stores the result in the hasKey variable. The System.debug statement outputs true, indicating that the key 'Alice' exists in the map.

See also: Methods in Salesforce Apex

Map Class Code Examples

How to declaration a map calss?

You can declare a Map in Salesforce using the following syntax:

   Map<KeyType, ValueType> mapName = new Map<KeyType, ValueType>();

• KeyType: The data type of the keys.
• ValueType: The data type of the values.

Adding Elements:
You can add key-value pairs to the map using the put() method:

   mapName.put(key, value);

Accessing Elements:
You can retrieve a value associated with a specific key using the get() method:

   ValueType retrievedValue = mapName.get(key);

See also: Objects in Salesforce apex

Checking for Key Existence:
You can check if a key exists in the map using the containsKey() method:

   Boolean keyExists = mapName.containsKey(key);

Iterating through Map:
You can iterate through the keys and values of a map using a for-each loop or by using the keySet() and values() methods:

   for (KeyType key : mapName.keySet()) {
       ValueType value = mapName.get(key);
       // Perform operations on key and value
   }

Size of Map:
To get the size (number of key-value pairs) of a map, use the size() method:

   Integer mapSize = mapName.size();

These are some of the common methods and operations you can perform with a Map class in Salesforce. Maps are quite versatile and useful for various scenarios, especially when dealing with complex data structures or organizing data efficiently.

See also: Variables in Salesforce Apex

Best practices

1. Define Key and Value Types: Clearly specify the data types for both keys and values in the map. This is crucial because Apex is a strongly typed language, and the types dictate what operations can be performed on the keys and values.
2. Initialization: Always initialize the map before using it. An uninitialized map will result in a NullPointerException when you try to add elements to it. You can initialize it when declaring, e.g., Map<String, Integer> myMap = new Map<String, Integer>();.
3. Key Uniqueness: Remember that each key in a map must be unique. If you insert a value with a key that already exists in the map, the new value will overwrite the existing one without any errors or warnings.
4. Null Keys: Apex maps do not support null keys, and attempting to use a null key will throw a runtime exception. However, null values are supported, so you can have a non-null key with a null value.
5. Choice of Key Type: Choose an appropriate data type for the keys based on the operations you need to perform. For example, using an Id type as the key is common when mapping records to their Salesforce record ID.
6. Efficiency Considerations: Maps are particularly efficient for lookups, insertions, and deletions, all of which are O(1) operations on average. This makes maps an excellent choice for high-performance scenarios.
7. Data Consistency: When using complex types like sObjects as map keys, be aware that the comparison is based on object identity, not on value equality. Therefore, two sObject instances with the same field values are considered different keys unless they are the same instance.

Checkout: Interfaces – Salesforce Apex

Common Mistakes

1. Not Initializing the Map: One of the most frequent errors is trying to use a map that has not been initialized. This will lead to a NullPointerException. Always initialize your map before using it, like so: Map<String, String> myMap = new Map<String, String>();.
2. Assuming Map Keys Are Case Insensitive: By default, string keys in Apex maps are case-sensitive. This means that keys “ABC” and “abc” would be considered different. Misunderstanding this could lead to unexpected behavior when retrieving values.
3. Using Null Keys: Apex does not allow null keys in a map. Attempting to use a null key will result in a runtime exception. Always check for null before using a value as a key.
4. Overwriting Values Unintentionally: Because adding an item with an existing key will overwrite the current value associated with that key, it’s important to check if a key already exists if overwriting is not intended. You can use the containsKey() method to check if a key already exists.
5. Ignoring Return Values of Remove Method: The remove() method returns the value associated with the key that was removed. Ignoring this return value can lead to losing track of what was removed, which might be critical depending on the application logic.
6. Not Using Available Map Methods: Apex provides a variety of useful map methods, such as keySet(), values(), and entrySet(), which can simplify code and enhance performance. Not using these methods can lead to more complex and less efficient implementations.
7. Modifying Map While Iterating: Modifying a map directly while iterating over its keys or values can cause ConcurrentModificationException. It’s safer to collect changes to apply after iteration or use an iterator explicitly if modifications during iteration are necessary.
8. Inefficient Use of Maps: Sometimes, developers use maps where a list or set would suffice, or they use a complex type as a key without needing to do so, which can lead to performance inefficiencies and increased memory usage.

See also: Constants in Salesforce Apex

Real-world example of Map Class

A real-world application of the Map class in Salesforce Apex could be to track the total sales by account based on recent Opportunities. This example would be particularly useful for a sales dashboard in a CRM, helping sales representatives quickly identify which accounts are generating the most revenue.

Here’s how you could write a simple program to achieve this:

// Apex program to calculate total sales by Account using a Map
public class TotalSalesByAccount {
    public static void calculateSales() {
        // Map to hold Account Ids and their corresponding total sales
        Map<Id, Decimal> salesByAccount = new Map<Id, Decimal>();

        // Query Opportunities that are closed and won
        List<Opportunity> opportunities = [
            SELECT Amount, AccountId
            FROM Opportunity
            WHERE StageName = 'Closed Won'
        ];

        // Iterate through each opportunity and sum the amounts by AccountId
        for (Opportunity opp : opportunities) {
            if (salesByAccount.containsKey(opp.AccountId)) {
                // If the account already exists in the map, add to the existing total
                salesByAccount.put(opp.AccountId, salesByAccount.get(opp.AccountId) + opp.Amount);
            } else {
                // Otherwise, add the account with the initial amount
                salesByAccount.put(opp.AccountId, opp.Amount);
            }
        }

        // Optionally, print the results for demonstration
        for (Id accountId : salesByAccount.keySet()) {
            System.debug('Account ID: ' + accountId + ' Total Sales: ' + salesByAccount.get(accountId));
        }
    }
}

In this program:

• A map named salesByAccount is created to associate each Account ID with its total sales amount.
• A list of Opportunity records is retrieved where the opportunity has been closed and won.
• The program iterates over these opportunities, checking if the Account ID is already in the map. If it is, the opportunity’s amount is added to the existing total. If not, a new key-value pair is created with the Account ID and the opportunity’s amount.
• Finally, the total sales per account are available in the map, which could be displayed on a dashboard or used for further analysis.
  

• Formula Fields
• Page Layouts
• Custom Page Layouts
• Record Types