💡 LearnFrenzy Insight

Imagine counting the number of stars in a galaxy or the total website visits over many years. A normal calculator can easily count hundreds or thousands, but eventually the numbers become extremely large.

Similarly, Integer has a maximum limit. When your value exceeds that limit, you should use the Long data type.

💡 Pro Tip: The L suffix is case-insensitive (you can use l or L), but using uppercase L is recommended for better readability.

⚠️ Important Note on Range: The Long range is approximately 9.2 quintillion (9.2 × 10^18). This is sufficient for almost all business applications, including counting records across multiple large Salesforce orgs.

📝 Key Points:

• Uninitialized Long variables default to null, not 0.
• Always use the L suffix when the value exceeds the Integer range.
• Values within the Integer range (-2,147,483,648 to 2,147,483,647) don't require the L suffix.
• Use descriptive names like totalApiRequests or storageUsed.

🏢 Business Scenario 1: Global API Request Tracking

A global company tracks the total number of API requests processed across all regions.

Long totalApiRequests = 8456789123L;
Long todaysRequests = 25894567L;

Long updatedTotal = totalApiRequests + todaysRequests;
System.debug('Previous Total: ' + totalApiRequests);
System.debug('Today\'s Requests: ' + todaysRequests);
System.debug('Updated Total: ' + updatedTotal);  // 8482683690

// Check if total exceeds 10 billion
if (updatedTotal > 10000000000L) {
    System.debug('API requests have exceeded 10 billion!');
} else {
    System.debug('API requests are within limit.');
}

Output

Previous Total: 8456789123
Today's Requests: 25894567
Updated Total: 8482683690
API requests are within limit.

A value of this size exceeds the Integer limit, making Long the appropriate choice.

🏢 Business Scenario 2: Large Data Migration

A company migrates data from a legacy system with billions of records.

// Records to migrate
Long legacyRecords = 12500000000L;
Long migratedSoFar = 4500000000L;

// Calculate remaining records
Long remainingRecords = legacyRecords - migratedSoFar;
System.debug('Total Records: ' + legacyRecords);
System.debug('Migrated So Far: ' + migratedSoFar);
System.debug('Remaining: ' + remainingRecords);  // 8000000000

// Progress percentage (converted to Long for display)
Long progressPercent = (migratedSoFar * 100) / legacyRecords;
System.debug('Migration Progress: ' + progressPercent + '%');  // 36%

// Estimated time calculation (if 1 million records per day)
Long recordsPerDay = 1000000L;
Long estimatedDays = remainingRecords / recordsPerDay;
System.debug('Estimated days remaining: ' + estimatedDays);  // 8000

Output

Total Records: 12500000000
Migrated So Far: 4500000000
Remaining: 8000000000
Migration Progress: 36%
Estimated days remaining: 8000

🏢 Business Scenario 3: Cloud Storage Analytics

Track storage usage across Salesforce orgs in bytes.

// Storage in bytes
Long storageUsed = 8796093022208L;    // 8 TB
Long storageLimit = 10995116277760L;  // 10 TB

// Calculate usage percentage
Long usagePercent = (storageUsed * 100) / storageLimit;
System.debug('Storage Used: ' + storageUsed + ' bytes');
System.debug('Storage Limit: ' + storageLimit + ' bytes');
System.debug('Usage: ' + usagePercent + '%');  // 80%

// Convert to human-readable format (approximate GB)
Long storageGB = storageUsed / (1024 * 1024 * 1024);
System.debug('Storage Used: ' + storageGB + ' GB');  // 8192 GB

// Alert if storage exceeds 90%
if (usagePercent > 90) {
    System.debug('Warning: Storage usage exceeds 90%!');
} else {
    System.debug('Storage usage is normal.');
}

Output

Storage Used: 8796093022208 bytes
Storage Limit: 10995116277760 bytes
Usage: 80%
Storage Used: 8192 GB
Storage usage is normal.

Developer Writes
Long totalRecords = 5000000000L;

        │
        ▼

Compiler Checks
✔ Long Type exists?
✔ Variable name valid?
✔ 'L' suffix present for large values?

        │
        ▼

Memory Allocated
64-bit (8 Bytes)

        │
        ▼

Value Stored in Binary
0100 1010 1001 0001 ... (64-bit representation)

        │
        ▼

Available for Arithmetic Operations
Used for counting, analytics, and storage

Long uses 64-bit storage, allowing it to hold values up to 9.2 quintillion.

Large Numeric Value Detected
Example: 5,000,000,000
        │
        ▼
Compiler Identifies as Long
Requires 64-bit storage
        │
        ▼
64-bit Storage Allocated
8 bytes of memory
        │
        ▼
Arithmetic Processing
Addition, Subtraction, etc.
        │
        ▼
Result Returned
Maintained as Long or converted

⚠️ Important: Converting Long to Integer can cause data loss if the Long value exceeds the Integer range. Always check the value before conversion.

✅ Best Practices

• Use Integer for normal counting operations (faster, less memory).
• Use Long only when values may exceed the Integer range (-2.1B to 2.1B).
• Append L to large numeric literals when declaring Long values.
• Use meaningful variable names such as totalApiRequests, storageUsed, or recordCount.
• Avoid using Long when Integer is sufficient, as Integer is simpler and uses less memory.
• Always check for null before performing arithmetic operations on Long variables.
• Use Long.valueOf() for safe string to Long conversion with error handling.
• Be cautious when converting Long to Integer - check if value fits in Integer range.
• Use Decimal for financial calculations, not Long.

⚠️ Common Mistakes

• Using Integer for values that exceed its maximum range (causes compile error).
• Forgetting the L suffix when writing large Long literals.
• Using Long for currency values instead of Decimal.
• Choosing Long unnecessarily when Integer is sufficient (wastes memory).
• Forgetting that uninitialized Long variables are null, not 0.
• Using == to compare Long objects without considering null values.
• Converting Long to Integer without checking for overflow.

🎯 Interview Tip

Question: When should you use Long instead of Integer in Apex?

Answer: Use Long when a whole number may exceed the Integer range of -2,147,483,648 to 2,147,483,647. Long supports a much larger 64-bit range (up to 9.2 × 10^18) and is commonly used for large counters, global analytics, integrations with external systems, and storage-related values.

Question: What is the purpose of the 'L' suffix in Long literals?

Answer: The L suffix tells the Apex compiler that the numeric literal should be treated as a Long instead of an Integer. Without the suffix, any number outside the Integer range will cause a compilation error. For example, 5000000000L is treated as a Long, while 5000000000 would cause an error.

Question: What happens when you convert a Long to an Integer in Apex?

Answer: Converting a Long to an Integer using longValue.intValue() can cause data loss if the Long value exceeds the Integer range. The value will be truncated modulo 2^32, potentially resulting in incorrect values. Always check if the Long value fits in the Integer range before conversion.

📌 Quick Revision

• ✔ Stores very large whole numbers (64-bit).
• ✔ Uses 64-bit (8-byte) memory allocation.
• ✔ Supports a much larger range than Integer (-9.2 × 10^18 to 9.2 × 10^18).
• ✔ Does not store decimal values (use Decimal for decimals).
• ✔ Commonly used for large counters, analytics, and storage sizes.
• ✔ Append L to large numeric literals (e.g., 5000000000L).
• ✔ Values within Integer range don't need the L suffix.
• ✔ Uninitialized Long variables default to null.
• ✔ Use Integer when possible (less memory, better performance).
• ✔ Common methods: Long.valueOf(), format(), compareTo().

➡ Next Lesson

In the next lesson, you'll learn about the Boolean data type, which stores only true or false values and is widely used for decision-making, conditional logic, validation, and business rules in Apex.