Collections

Collections are one of the most powerful and frequently used features in Apex programming. Collections allow developers to store and manage multiple values efficiently. Instead of creating separate variables for every record or value, collections provide structured containers that can hold large amounts of data and support advanced operations such as searching, sorting, filtering, and bulk processing.

In Salesforce development, collections are essential because most operations involve multiple records. Whether processing Accounts, Contacts, Leads, Opportunities, Students, Courses, or Payments, developers use collections to work with groups of records efficiently while staying within Salesforce Governor Limits.

Understanding Collections is critical for Salesforce Developers because they are used extensively in Apex Classes, Triggers, Batch Apex, Integrations, Lightning Components, and Flow Actions.

What are Collections?

Collections are data structures used to store multiple values in a single variable.

Collections help developers:

• Store Multiple Records
• Process Large Data Sets
• Improve Performance
• Reduce Code Complexity
• Support Bulk Operations

Collections are fundamental to efficient Apex development.

Why Collections are Important?

Salesforce applications frequently work with:

• Multiple Accounts
• Multiple Contacts
• Multiple Opportunities
• Multiple Students
• Multiple Payments

Creating individual variables for each record would be impractical.

Collections provide a scalable solution.

Benefits of Collections

Efficient Data Management

Store multiple values together.

Better Performance

Reduce unnecessary processing.

Governor Limit Compliance

Support bulk operations.

Improved Readability

Simplify code structure.

Faster Development

Reduce repetitive coding.

These benefits make collections essential in Apex.

Types of Collections in Apex

Apex supports three primary collection types.

List

Set

Map

Each collection serves a different purpose.

Collection Overview

Understanding when to use each collection is an important developer skill.

List Collection

What is a List?

A List is an ordered collection that can store multiple values.

Characteristics:

• Ordered
• Allows Duplicates
• Indexed
• Dynamic Size

Lists are the most commonly used collection type.

Creating a List

Syntax:

List<DataType> variableName =
new List<DataType>();

Example:

List<String> courses =
new List<String>();

This creates an empty list.

Adding Values to a List

Example:

List<String> courses =
new List<String>();

courses.add('Salesforce');
courses.add('Python');
courses.add('Java');

The list now contains three values.

Displaying List Values

Example:

System.debug(courses);

Output:

(Salesforce, Python, Java)

Lists can hold multiple records efficiently.

Accessing List Elements

Lists use index positions.

Example:

List<String> courses =
new List<String>{
    'Salesforce',
    'Python',
    'Java'
};

System.debug(
    courses[0]
);

Output:

Salesforce

Indexing starts from zero.

List Index Positions

Understanding indexes is important when working with lists.

Updating List Values

Example:

courses[1] = 'Data Science';

Result:

(Salesforce, Data Science, Java)

Lists allow value modification.

Removing Values from a List

Example:

courses.remove(1);

Result:

(Salesforce, Java)

The element at index 1 is removed.

List Size

What is Size?

Size returns the number of elements.

Example:

System.debug(
    courses.size()
);

Output:

2

Useful for validations and loops.

Looping Through a List

Example:

for(String course : courses){

    System.debug(course);

}

Output:

Salesforce
Java

This is called a For-Each Loop.

List of Salesforce Records

Example:

List<Account> accounts =
[
    SELECT Id, Name
    FROM Account
];

Lists commonly store Salesforce records.

Set Collection

What is a Set?

A Set is an unordered collection that stores unique values.

Characteristics:

• Unordered
• No Duplicates
• Dynamic Size
• Fast Searching

Sets are useful when duplicates must be prevented.

Creating a Set

Example:

Set<String> skills =
new Set<String>();

Creates an empty set.

Adding Values to a Set

Example:

skills.add('Java');
skills.add('Python');
skills.add('Java');

Result:

(Java, Python)

Duplicate values are automatically removed.

Why Use Sets?

Sets are useful for:

Removing Duplicates

Fast Membership Checks

Bulk Data Processing

Data Validation

These capabilities improve performance.

Checking Values in a Set

Example:

Boolean exists =
skills.contains('Python');

System.debug(exists);

Output:

true

Useful for validation logic.

Removing Values from a Set

Example:

skills.remove('Java');

Result:

(Python)

Values can be removed easily.

Set Size

Example:

System.debug(
    skills.size()
);

Output:

1

Size returns the total number of unique values.

Looping Through a Set

Example:

for(String skill : skills){

    System.debug(skill);

}

Output:

Python

Sets support iteration similar to lists.

Set Example with Record IDs

Set<Id> accountIds =
new Set<Id>();

Commonly used in Triggers and Bulk Processing.

Map Collection

What is a Map?

A Map stores data as key-value pairs.

Characteristics:

• Key-Value Structure
• Unique Keys
• Fast Retrieval
• Dynamic Size

Maps are widely used in Apex development.

Understanding Key-Value Pairs

Example:

Each key uniquely identifies a value.

Creating a Map

Example:

Map<Integer, String>
students =
new Map<Integer, String>();

Creates an empty map.

Adding Values to a Map

Example:

students.put(101, 'Rahul');

students.put(102, 'Priya');

students.put(103, 'Amit');

The map now contains three records.

Accessing Map Values

Example:

System.debug(
    students.get(101)
);

Output:

Rahul

Maps retrieve values using keys.

Updating Map Values

Example:

students.put(
    101,
    'Rahul Sharma'
);

The existing value is updated.

Removing Values from a Map

Example:

students.remove(102);

The key-value pair is removed.

Checking Keys in a Map

Example:

Boolean exists =
students.containsKey(101);

Output:

true

Useful for validations.

Map Size

Example:

System.debug(
    students.size()
);

Output:

2

Returns total entries.

Looping Through a Map

Example:

for(Integer key :
students.keySet()){

    System.debug(
        students.get(key)
    );

}

Output:

Rahul Sharma
Amit

Maps support iteration through keys.

Map with Salesforce Records

Example:

Map<Id, Account>
accountMap =
new Map<Id, Account>(
[
    SELECT Id, Name
    FROM Account
]
);

This is one of the most common Apex patterns.

Collections and Governor Limits

Collections help reduce:

SOQL Queries

DML Operations

CPU Usage

Bulkified code relies heavily on collections.

Collections in Triggers

Bad Practice:

for(Account acc : Trigger.new){

    insert new Contact();

}

Good Practice:

List<Contact> contacts =
new List<Contact>();

for(Account acc : Trigger.new){

    contacts.add(
        new Contact()
    );

}

insert contacts;

Collections improve performance and scalability.

Choosing the Right Collection

Selecting the correct collection improves code quality.

Collections Best Practices

Use Lists for Ordered Data

Use Sets for Unique Values

Use Maps for Fast Retrieval

Avoid Duplicate Processing

Bulkify Operations

Minimize SOQL Queries

These practices support efficient Apex development.

Common Mistakes

Using Lists Instead of Sets

Ignoring Map Efficiency

Processing Records Individually

Excessive Looping

Poor Collection Selection

Developers should choose collections carefully.

Real-World Example

A software training company processes student enrollments.

List<String> students =
new List<String>{
    'Rahul',
    'Priya',
    'Amit'
};

Set<String> courses =
new Set<String>{
    'Salesforce',
    'Python'
};

Map<Integer, String>
batchMap =
new Map<Integer, String>{
    101 => 'Morning Batch',
    102 => 'Evening Batch'
};

Collections help organize and process large amounts of information efficiently.

Why Collections Matter for Salesforce Professionals

Understanding Collections helps professionals:

• Process Salesforce records efficiently
• Build scalable applications
• Avoid Governor Limit issues
• Develop optimized Apex code
• Prepare for Salesforce certifications

Collections are among the most important Apex concepts.

Summary

Collections are data structures used to store and manage multiple values efficiently in Apex. Salesforce supports three primary collection types: Lists for ordered data, Sets for unique values, and Maps for key-value relationships. Collections are essential for bulk processing, performance optimization, Governor Limit compliance, and scalable Salesforce development.

Frequently Asked Questions (FAQs)

What are Collections in Apex?

Collections are data structures used to store multiple values in a single variable.

What are the three collection types in Apex?

List, Set, and Map.

Which collection allows duplicate values?

List allows duplicate values.

Which collection prevents duplicates?

Set automatically removes duplicate values.

What is a Map?

A Map stores data as key-value pairs.

Why are Collections important in Salesforce?

They support bulk processing, improve performance, and help avoid Governor Limit issues.

Internal Resources

Looking to learn more technologies and programming skills?

Click here for more free courses.