Technology has always been a bridge, but today, it feels more like a mirror. With the rapid rise of AI , we are seeing things enter our lives and leave them at a pace we can barely track. To understand where this is going, we first have to understand how technology actually impacts the core of who we are. The Survivalist vs. The Ego Our minds are biologically wired for one thing: survival . We are designed to handle the worst-case scenario, an ancient instinct gifted to us by nature. We consider ourselves conscious decision-makers, but a critical question remains: Who is really making the call?
Introduction:
Apex, the programming language used in Salesforce, provides powerful data structures to handle collections of data efficiently. In this blog post, we will explore three fundamental collection types in Apex: Lists, Sets, and Maps. Understanding these collection types and their appropriate use cases will enhance your development skills and enable you to write more efficient code.
Table of Contents:
1. Introduction
2. Lists
- Declaration and Initialization
- Adding and Removing Elements
- Accessing Elements
- Example: Storing a List of Contacts
3. Sets
- Declaration and Initialization
- Adding and Removing Elements
- Checking for Duplicates
- Example: Maintaining a Set of Unique Email Addresses
4. Maps
- Declaration and Initialization
- Adding and Retrieving Key-Value Pairs
- Updating and Removing Entries
- Example: Mapping Account Names to Associated Opportunities
5. Conclusion
Lists:
A list is an ordered collection of elements of the same data type. It allows duplicate values and provides methods to add, remove, and access elements based on their index.
Declaration and Initialization:
List<String> fruits = new List<String>(); // Empty list
List<String> colors = new List<String>{'Red', 'Green', 'Blue'}; // List with initial values
Adding and Removing Elements:
fruits.add('Apple'); // Add an element to the end of the list
fruits.addAll(colors); // Add all elements from another list
fruits.remove(0); // Remove the element at index 0
Accessing Elements:
String firstFruit = fruits[0]; // Access element at index 0
Integer listSize = fruits.size(); // Get the number of elements in the list
Example: Storing a List of Contacts:
List<Contact> contactList = [SELECT Id, FirstName, LastName FROM Contact LIMIT 10];
Sets:
A set is an unordered collection of unique elements. It does not allow duplicate values and provides methods to add, remove, and check for membership efficiently.
Declaration and Initialization:
Set<String> cities = new Set<String>(); // Empty set
Set<String> uniqueColors = new Set<String>{'Red', 'Green', 'Blue'}; // Set with initial values
Adding and Removing Elements:
cities.add('New York'); // Add an element to the set
cities.addAll(uniqueColors); // Add all elements from another set
cities.remove('New York'); // Remove a specific element
Checking for Duplicates:
Boolean containsRed = uniqueColors.contains('Red'); // Check if the set contains an element
Example:
Maintaining a Set of Unique Email Addresses:
Set<String> uniqueEmails = new Set<String>();
for (Contact contact : contactList) {
uniqueEmails.add(contact.Email);
}
Maps:
A map is a collection of key-value pairs, where each key is unique. It provides methods to add, retrieve, update, and remove entries efficiently based on the key.
Declaration and Initialization:
Map<String, Integer> scores = new Map<String, Integer>(); // Empty map
Map<String, String> countryCodes = new Map<String, String>{'US' => 'United States', 'CA' => 'Canada'}; // Map with initial values
Adding and Retrieving Key-Value Pairs:
scores.put('John', 90); // Add a key-value pair to the map
Integer johnScore = scores.get('John'); // Retrieve the value for a specific key
Updating and Removing Entries:
scores.put('John', 95); // Update the value for an existing key
scores.remove('John'); // Remove a specific key-value pair
Example:
Mapping Account Names to Associated Opportunities:
Map<String, List<Opportunity>> accountOpportunities = new Map<String, List<Opportunity>>();
for (Opportunity opp : opportunitiesList) {
if (!accountOpportunities.containsKey(opp.AccountId)) {
accountOpportunities.put(opp.AccountId, new List<Opportunity>());
}
accountOpportunities.get(opp.AccountId).add(opp);
}
Conclusion:
Lists, sets, and maps are fundamental collection types in Apex Salesforce that allow efficient storage and retrieval of data. By understanding their features and appropriate use cases, you can enhance your development skills and write more efficient code. Lists are suitable for ordered collections with potential duplicates, sets ensure uniqueness, and maps enable mapping between keys and values. Harnessing the power of these collection types will help you build robust Salesforce applications.