Salesforce Development లో మీరు ఏ ఇంటర్వ్యూకి వెళ్లినా, లేదా ఏ రియల్-టైమ్ ప్రాజెక్ట్లో పనిచేసినా, అత్యంత ముఖ్యమైన అంశం Apex Collections (List, Set, Map). Salesforce Multi-Tenant Architecture లో పనిచేస్తుంది కాబట్టి, ఇక్కడ Governor Limits చాలా కఠినంగా ఉంటాయి. ఒక్కొక్క రికార్డుపై విడివిడిగా SOQL లేదా DML ఆపరేషన్లు చేస్తే కోడ్ వెంటనే ఫెయిల్ అవుతుంది.
ఆ సమస్యను అధిగమించి, వందల లేదా వేల సంఖ్యలో ఉన్న రికార్డులను ఒకేసారి సమర్థవంతంగా ప్రాసెస్ చేయడానికి (Bulkification) మనకు Collections ఉపయోగపడతాయి. ఈ రోజు మనం List, Set, మరియు Map గురించి ప్రతి చిన్న వివరంతో, రియల్-టైమ్ కోడ్ ఉదాహరణలతో నేర్చుకుందాం.
1. Apex Collections అంటే ఏమిటి?
ఒకే రకమైన అనేక డేటా విలువలను (Primitive Data Types, SObjects, లేదా ఇతర Collections) ఒకే వేరియబుల్లో నిల్వ (Store) చేయడానికి ఉపయోగించే డేటా స్ట్రక్చర్లను Collections అంటారు. సాధారణ వేరియబుల్లో ఒకే విలువను స్టోర్ చేయగలం, కానీ Collection లో ఎన్ని విలువలను అయినా స్టోర్ చేయవచ్చు.
Salesforce Apex లో మూడు రకాల Collections ఉన్నాయి:
- List: క్రమబద్ధమైన (Ordered) మరియు డూప్లికేట్ విలువలను అనుమతించే కలెక్షన్.
- Set: క్రమరహితమైన (Unordered) మరియు కేవలం ప్రత్యేకమైన (Unique) విలువలను మాత్రమే అనుమతించే కలెక్షన్.
- Map: Key-Value జతల (Pairs) రూపంలో డేటాను నిల్వ చేసే అత్యంత శక్తివంతమైన కలెక్షన్.
2. List (లిస్ట్) – పూర్తి వివరణ
List అనేది Apex లో అత్యధికంగా ఉపయోగించే కలెక్షన్. మీరు SOQL Query రాసినప్పుడు వచ్చే ఫలితం ఎల్లప్పుడూ List<SObject> రూపంలోనే వస్తుంది. List లోని ప్రతి ఎలిమెంట్కు ఒక Index Number ఉంటుంది, ఇది ఎల్లప్పుడూ 0 నుండి మొదలవుతుంది.
- Ordered: మీరు ఏ క్రమంలో విలువలను యాడ్ చేస్తారో, అదే క్రమంలో స్టోర్ అవుతాయి.
- Duplicates Allowed: ఒకే విలువను ఎన్నిసార్లు అయినా List లో యాడ్ చేయవచ్చు.
- Dynamic Size: Array లాగా ముందుగానే సైజు చెప్పాల్సిన అవసరం లేదు; డేటా యాడ్ చేసేకొద్దీ దానంతట అదే పెరుగుతుంది.
// List డిక్లరేషన్
List<String> cityList = new List<String>();
// విలువలను యాడ్ చేయడం
cityList.add('Hyderabad');
cityList.add('Bengaluru');
cityList.add('Chennai');
cityList.add('Hyderabad'); // Duplicate అనుమతిస్తుంది
System.debug('మొత్తం Cities: ' + cityList);
System.debug('మొదటి City (Index 0): ' + cityList.get(0));
System.debug('List సైజు: ' + cityList.size());
// ఒక విలువ ఉందో లేదో చెక్ చేయడం
if (cityList.contains('Bengaluru')) {
System.debug('Bengaluru ఈ లిస్ట్లో ఉంది!');
}
3. Set (సెట్) – డూప్లికేట్లను తొలగించడానికి
ఒకవేళ మీ దగ్గర 1,000 Contact రికార్డులు ఉండి, వాటికి సంబంధించిన Account Ids అన్నీ డూప్లికేట్లు లేకుండా కావాలి అనుకోండి. అలాంటప్పుడు Set ఉపయోగించాలి. Set లోకి మీరు ఒకే విలువను పదిసార్లు యాడ్ చేసినా, అది ఒక్కసారి మాత్రమే స్టోర్ చేసుకుంటుంది.
- Unordered: ఇందులో Index Numbers ఉండవు. కాబట్టి
set.get(0)అనే మెథడ్ పనిచేయదు. - No Duplicates: డూప్లికేట్ విలువలను ఆటోమేటిక్గా విస్మరిస్తుంది (Case-sensitive for Strings).
- Best Use Case: Parent Record Ids ని సేకరించి, వాటిపై SOQL Query రాయడానికి Set అద్భుతంగా పనిచేస్తుంది.
Set<String> skillSet = new Set<String>{'Apex', 'LWC', 'Admin', 'Apex'};
System.debug('Unique Skills: ' + skillSet); // Output: {Admin, Apex, LWC}
System.debug('Set సైజు: ' + skillSet.size()); // Output: 3
// Set లో ఉన్న విలువలను Loop చేయడం
for (String skill : skillSet) {
System.debug('Skill: ' + skill);
}
String Set లో
'Salesforce' మరియు 'salesforce' లను రెండు వేర్వేరు విలువలుగా పరిగణిస్తుంది. ఎందుకంటే Apex లో String పోలికలు Set మరియు Map Keys విషయంలో Case-Sensitive గా ఉంటాయి.
4. Map (మ్యాప్) – Salesforce Bulkification కి వెన్నెముక
రియల్-టైమ్ Salesforce Development లో Map లేకుండా ఏ పెద్ద Trigger లేదా Integration రాయలేము. Map లో డేటా Key మరియు Value జతలుగా ఉంటుంది. ప్రతి Key తప్పనిసరిగా Unique అయి ఉండాలి, కానీ Values డూప్లికేట్ కావచ్చు.
ఉదాహరణకు: ఒక Employee ID (Key) ఇస్తే, ఆ Employee పూర్తి వివరాలు (Value) క్షణాల్లో పొందవచ్చు. ఇందుకోసం Loop తిప్పాల్సిన అవసరం లేకుండా map.get(key) ద్వారా నేరుగా డేటాను తీసుకోవచ్చు.
// Map డిక్లరేషన్: Key = Integer (Emp ID), Value = String (Emp Name)
Map<Integer, String> empMap = new Map<Integer, String>();
// డేటా యాడ్ చేయడం (put method)
empMap.put(101, 'Ravi Kumar');
empMap.put(102, 'Sneha Reddy');
empMap.put(103, 'Kiran Babu');
// అదే Key తో మళ్ళీ put చేస్తే పాత Value Replace అవుతుంది
empMap.put(101, 'Ravi Teja');
System.debug('Employee 101 Name: ' + empMap.get(101)); // Output: Ravi Teja
System.debug('అన్ని Keys (Set): ' + empMap.keySet());
System.debug('అన్ని Values (List): ' + empMap.values());
if (empMap.containsKey(102)) {
System.debug('102 ID ఉన్న ఉద్యోగి ఉన్నారు.');
}
5. Real-Time Trigger Scenario: SOQL Query ని Map లోకి నేరుగా లోడ్ చేయడం
Salesforce లో ఒక అద్భుతమైన షార్ట్కట్ ఉంది. ఒక SOQL Query ఫలితాన్ని నేరుగా Map<Id, SObject> లోకి పాస్ చేయవచ్చు. దీనివల్ల Loop తిప్పకుండానే Record Id ఆధారంగా ఆ రికార్డును పొందవచ్చు.
// SOQL Query ఫలితాన్ని నేరుగా Map లోకి తీసుకోవడం
Map<Id, Account> accountMap = new Map<Id, Account>(
[SELECT Id, Name, Industry, Phone FROM Account LIMIT 50]
);
// ఇప్పుడు ఏదైనా ఒక Account Id మన దగ్గర ఉంటే:
for (Id accId : accountMap.keySet()) {
Account acc = accountMap.get(accId);
System.debug('Account Name: ' + acc.Name + ' | Industry: ' + acc.Industry);
}
6. List vs Set vs Map – పూర్తి పోలిక పట్టిక
| లక్షణం (Feature) | List | Set | Map |
|---|---|---|---|
| Data Format | Single Elements | Single Unique Elements | Key-Value Pairs |
| Duplicates | అనుమతిస్తుంది (Allowed) | అనుమతించదు (Not Allowed) | Keys: అనుమతించదు Values: అనుమతిస్తుంది |
| Order & Index | Ordered (Index 0, 1, 2...) | Unordered (No Index) | Unordered (Accessed by Key) |
| Insert Method | .add(value) |
.add(value) |
.put(key, value) |
| SOQL Support | నేరుగా సపోర్ట్ చేస్తుంది | నేరుగా సపోర్ట్ చేయదు | Map<Id, SObject> సపోర్ట్ చేస్తుంది |
7. డెవలపర్లు చేసే సాధారణ తప్పులు (Common Mistakes)
ఒక List లో 3 ఎలిమెంట్లు మాత్రమే ఉండి (Index 0, 1, 2), మీరు
myList.get(3) అని యాక్సెస్ చేయడానికి ప్రయత్నిస్తే System.ListException: List index out of bounds: 3 ఎర్రర్ వస్తుంది. ఎల్లప్పుడూ ముందుగా !myList.isEmpty() చెక్ చేయండి.2. Null Check లేకుండా Map.get() వాడటం:
Map లో లేని Key కోసం
empMap.get(999) కాల్ చేస్తే అది null ఇస్తుంది. దానిపై వెంటనే ఫీల్డ్ యాక్సెస్ చేస్తే NullPointerException వస్తుంది. కాబట్టి ఎప్పుడూ ముందుగా empMap.containsKey(999) చెక్ చేయాలి.
8. తరచుగా అడిగే ఇంటర్వ్యూ ప్రశ్నలు (Interview Q&A)
Q1: List లో ఉన్న డూప్లికేట్ విలువలను ఒకే లైన్లో ఎలా తొలగించాలి?
జవాబు: ఆ List ను ఒక Set కన్స్ట్రక్టర్లోకి పాస్ చేయడం ద్వారా డూప్లికేట్లన్నీ తొలగిపోతాయి. ఉదాహరణకు:
Set<String> uniqueSet = new Set<String>(myDuplicateList);
Q2: Apex Triggers లో Trigger.newMap మరియు Trigger.oldMap ఏ డేటా టైప్లో ఉంటాయి?
జవాబు: అవి రెండూ Map<Id, SObject> రూపంలో ఉంటాయి. ఇందులో Key అనేది ఆ రికార్డు యొక్క Salesforce 18-character Id, మరియు Value అనేది ఆ పూర్తి రికార్డు.
Q3: Nested Loop (Loop లోపల Loop) నివారించడానికి ఏ Collection వాడతాము?
జవాబు: Map వాడతాము. Parent మరియు Child రికార్డులను పోల్చడానికి Nested Loop రాస్తే CPU Time Limit ఎర్రర్ వస్తుంది. బదులుగా Parent రికార్డులను Map<Id, ParentObject> లో పెట్టుకుని, Child Loop లో map.get(child.ParentId) ద్వారా O(1) వేగంతో యాక్సెస్ చేస్తాము.
ముగింపు (Summary)
Salesforce Apex లో List, Set, మరియు Map అనేవి మూడు కీలక స్తంభాలు. డేటాను క్రమపద్ధతిలో ఉంచడానికి List, డూప్లికేట్లను ఫిల్టర్ చేయడానికి Set, మరియు వేగవంతమైన డేటా లుకప్ & Bulkification కోసం Map ఉపయోగించాలి. ఈ మూడింటిపై పట్టు సాధిస్తే మీరు Apex Triggers ను చాలా సులభంగా రాయగలరు.
తర్వాతి ఆర్టికల్లో మనం DML Operations in Salesforce Apex (Insert, Update, Upsert, Delete, Undelete & Database Methods) గురించి పూర్తి వివరాలతో నేర్చుకుందాం!

0 Comments