The Complete Guide to Apex Variables - Master Salesforce Data Types

Introduction

Variables are the foundation of Apex, Salesforce’s powerful programming language. This comprehensive guide takes you beyond the basics, covering everything from primitive types to advanced collection techniques with real-world examples and code snippets.

Learn how to optimize your Apex code through efficient variable management, understand Salesforce-specific constraints, and implement proven best practices that improve performance and maintainability in your Salesforce development projects. Whether you’re building triggers, batch processes, or integration services, these techniques will help you write more robust Apex code.

Primitive Data Types

Apex supports various primitive data types that store simple values. Understanding these fundamental building blocks is crucial for effective Apex development.

Integer

Integers represent whole numbers without decimal points and are commonly used for counters, indexes, and mathematical operations.

Integer recordCount = 42;
Integer offset = -7;
Integer totalItems = recordCount + 10;

// Integer has a maximum value
Integer maxValue = 2147483647; // Max positive value
Integer minValue = -2147483648; // Max negative value

Performance Tip: For large numerical values exceeding Integer limits, use Long instead to avoid overflow errors.

Long

The Long data type handles larger whole numbers than Integer, useful for large numerical values.

Long veryLargeNumber = 9223372036854775807L; // Note the 'L' suffix
Long calculationResult = 2147483647L * 2L;

// Converting between types
Integer regularNum = 100;
Long largeNum = regularNum;

Decimal

For precise decimal calculations, especially in financial applications, the Decimal type is essential.

Decimal projectBudget = 1250.50;
Decimal taxRate = 0.0875;
Decimal totalWithTax = projectBudget * (1 + taxRate);

// Controlling precision
Decimal roundedAmount = totalWithTax.setScale(2);

Best Practice: Always use Decimal, not Double, for financial calculations to avoid floating-point precision issues.

Double

The Double type handles floating-point numbers but with potential precision limitations.

Double latitude = 37.7749;
Double longitude = -122.4194;
Double calculation = latitude * 2;

String

Strings store text data and offer numerous built-in methods for manipulation.

String firstName = 'Apex';
String lastName = 'Anvil';
String fullName = firstName + ' ' + lastName;

// String methods
Boolean containsA = firstName.contains('A'); // true
String upperName = fullName.toUpperCase(); // APEX ANVIL
String sub = lastName.substring(0, 3); // Anv
Integer nameLength = fullName.length(); // 10

Boolean

Boolean variables store true/false values, ideal for conditional logic.

Boolean isActive = true;
Boolean hasPermission = false;
Boolean complexCondition = isActive && hasPermission;

Date and DateTime

These types handle date and time values, crucial for record tracking and time-based operations.

// Current date and time
Date today = Date.today();
DateTime now = DateTime.now();

// Creating specific dates
Date specificDate = Date.newInstance(2025, 3, 14);
DateTime specificDateTime = DateTime.newInstance(2025, 3, 14, 10, 30, 0);

// Date arithmetic
Date nextWeek = today.addDays(7);
Date threeMonthsAgo = today.addMonths(-3);

// Formatting
String formattedDate = now.format('MM/dd/yyyy hh:mm a');

Timezone Tip: Use DateTime.newInstanceGmt() for creating GMT times zones and be mindful of users’ timezones when displaying DateTime values.

Blob

Blob variables store binary data, useful for file handling and encryption.

Blob pdfContent = Blob.valueOf('Sample content');

// Encryption example (complete)
Blob myKey = Crypto.generateAesKey(128);
Blob myIV = Crypto.generateIv(128);
Blob encryptedData = Crypto.encrypt('AES128', myKey, myIV, pdfContent);

// Converting between Blob and String
String decoded = pdfContent.toString();

ID

The ID type specifically handles Salesforce record identifiers.

Id accountId = '001R0000003TYeQIAW';
Id contactId;

// Type checking
Boolean isAccount = (accountId.getSObjectType() == Account.SObjectType);

Top Tip: You can validate ID types before performing DML operations to prevent runtime errors.

Collections

Collections are essential for managing groups of values. Apex provides three primary collection types, each with unique properties.

Lists (Arrays)

Lists store ordered collections of elements and allow duplicates.

// Declaring and initializing lists
List<String> browsers = new List<String>{'Chrome', 'Firefox', 'Safari'};
List<Integer> taskPriorities = new List<Integer>();
String[] frameworks = new String[]{'Lightning', 'Aura', 'Visualforce'};

// Adding elements
taskPriorities.add(1);  // Critical
taskPriorities.add(2);  // High
taskPriorities.addAll(new List<Integer>{3, 4, 5}); // Medium, Low, Optional

// Accessing elements
String firstBrowser = browsers[0]; // Chrome
browsers.set(1, 'Edge'); // Replace Firefox with Edge

// List operations
Integer browserCount = browsers.size(); // 3
Boolean hasChrome = browsers.contains('Chrome'); // true
browsers.sort(); // ['Chrome', 'Edge', 'Safari']

// Removing elements
browsers.remove(2); // Remove by index
browsers.clear(); // Remove all elements

Nested Lists

You can create multi-dimensional structures with nested lists.

List<List<Integer>> matrix = new List<List<Integer>>();
matrix.add(new List<Integer>{1, 2, 3});
matrix.add(new List<Integer>{4, 5, 6});

// Accessing nested elements
Integer value = matrix[0][1]; // 2

Sets

Sets store unordered collections of unique elements, ideal for eliminating duplicates.

// Creating sets
Set<String> uniqueErrors = new Set<String>{
        'NullPointer',
        'OutOfBounds',
        'NullPointer'
}; // Contains only 'NullPointer' and 'OutOfBounds'

// Adding elements
Set<Id> teamUserIds = new Set<Id>();
Id adminId = '005R0000003AAAAAA3'; // Example ID
teamUserIds.add(adminId);
// Add more team members
teamUserIds.addAll(new Set<Id>{'005R0000003BBBBBB3', '005R0000003CCCCCCC3'});

// Set operations
Boolean hasNullPointer = uniqueErrors.contains('NullPointer'); // true
Integer errorCount = uniqueErrors.size(); // 2

// Converting between lists and sets
List<String> errorsList = new List<String>(uniqueErrors);
Set<String> errorsSet = new Set<String>(errorsList);

Set Operations

Sets support mathematical set operations.

Set<Integer> setA = new Set<Integer>{1, 2, 3, 4};
Set<Integer> setB = new Set<Integer>{3, 4, 5, 6};

// Union - create a new set with all elements
Set<Integer> unionSet = new Set<Integer>(setA);
unionSet.addAll(setB); // {1, 2, 3, 4, 5, 6}

// Intersection - create a new set with elements in both sets
Set<Integer> intersectionSet = new Set<Integer>(setA);
intersectionSet.retainAll(setB); // {3, 4}

// Difference - create a new set with elements in A but not in B
Set<Integer> differenceSet = new Set<Integer>(setA);
differenceSet.removeAll(setB); // {1, 2}

Maps

Maps store key-value pairs, providing efficient lookups.

// Creating maps
Map<Id, Account> accountsById = new Map<Id, Account>();
Map<String, Integer> projectHours = new Map<String, Integer>{
    'ApexAnvil Homepage' => 12,
    'Integration Module' => 24,
    'Admin Dashboard' => 36
};

// Adding entries
Account newAccount = new Account(Name = 'Test Account');
insert newAccount; // This gives the account an ID
accountsById.put(newAccount.Id, newAccount);
projectHours.put('Bug Fix Sprint', 42);

// Accessing values
Integer integrationTime = projectHours.get('Integration Module'); // 24
Id targetId = newAccount.Id;
Account retrievedAccount = accountsById.get(targetId);

// Checking content
Boolean hasBugFix = projectHours.containsKey('Bug Fix Sprint'); // true
Set<String> projects = projectHours.keySet();
List<Integer> hoursList = projectHours.values();

// Iterating through a map
for(String project : projectHours.keySet()) {
    Integer hours = projectHours.get(project);
    System.debug(project + ' required ' + hours + ' development hours');
}

Performance Tip: Store records in a Map with IDs as keys (like Map<Id, Account>) for fast lookups. Finding a record by ID in a Map is instant, while searching through a List gets slower as the List grows larger.

Nested Maps

Complex data structures can be created with nested maps.

// Map of maps - developer -> (language -> experience years)
Map<String, Map<String, Integer>> developerSkills = new Map<String, Map<String, Integer>>();

// Adding nested data
developerSkills.put('Developer One', new Map<String, Integer>{
    'Apex' => 5,
    'JavaScript' => 3
});

// Accessing nested data - make sure to check for null
if (developerSkills.containsKey('Developer One')) {
    Map<String, Integer> skills = developerSkills.get('Developer One');
    if (skills.containsKey('Apex')) {
        Integer apexYears = skills.get('Apex'); // 5
        System.debug('Developer has ' + apexYears + ' years of Apex experience');
    }
}

SObject Variables

SObjects are Salesforce’s database objects and have special handling in Apex.

Standard and Custom Objects

// Creating new sObject instances
Account newAccount = new Account(Name = 'ApexAnvil Inc', Industry = 'Technology');
Contact newContact = new Contact();
newContact.FirstName = 'John';
newContact.LastName = 'Developer';
newContact.Email = '[email protected]';

// Custom objects (assuming this custom object exists in your org)
MyCustomObject__c newRecord = new MyCustomObject__c(
    Name = 'Web Portal Redesign',
    Status__c = 'In Progress',
    Priority__c = 'High'
);

SObject Fields and Dynamic Access

// Direct field access
String accountName = newAccount.Name;

// Dynamic field access
Object fieldValue = newAccount.get('Name');
newAccount.put('Phone', '(415) 555-1212');

// Field exists check
Boolean hasField = newAccount.isSet('Website');

// Get all populated fields
Map<String, Object> populatedFields = newAccount.getPopulatedFieldsAsMap();

Generic SObject Type

// Using generic SObject
SObject record = new Account(Name = 'Universal Corp');
SObject queriedRecord = Database.query('SELECT Id, Name FROM Account LIMIT 1');

// Type casting - always check type first
if (queriedRecord instanceof Account) {
    Account retrievedAccount = (Account)queriedRecord;
    System.debug('Account name: ' + retrievedAccount.Name);
}

Top Tip: You can verify object types when casting to avoid runtime errors.