𝗠𝗮𝘀𝘁𝗲𝗿 𝗝𝗮𝘃𝗮 𝗖𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻𝘀
பெரும்பாலான டெவலப்பர்கள் இயல்பாகவே ArrayList அல்லது HashSet-ஐப் பயன்படுத்துகிறார்கள். இது எளிமையான பணிகளுக்குச் சரியாக இருக்கும். ஆனால் வேகம் அல்லது அளவிடுதல் (scale) தேவைப்படும்போது இது தோல்வியடையும்.
நான் ஒருமுறை ஒரு சாதாரண ArrayList-ஐப் பயன்படுத்தி ஒரு கேம் லீடர்போர்டை (game leaderboard) உருவாக்கினேன். ஒவ்வொரு முறை ஸ்கோர் மாறும்போது நான் அதை வரிசைப்படுத்தினேன் (sort). இதனால் UI அடிக்கடி முடங்கியது (freeze). நான் மொழியைப் பயன்படுத்துவதற்குப் பதிலாக, அதனுடன் போராடிக்கொண்டிருந்தேன்.
தவறான கருவிகளைப் பயன்படுத்துவதை நிறுத்துங்கள். வேகமான மற்றும் சுத்தமான குறியீட்டை (code) எழுத இந்த மூன்று சிறப்பு Collections-களைப் பயன்படுத்துங்கள்.
- Enum Constants-களுக்கு EnumSet
நீங்கள் enums-களுக்கு HashSet-ஐப் பயன்படுத்தினால், செயல்திறன் இழப்பைச் (performance tax) சந்திக்க நேரிடும். ஒவ்வொரு முறை சேர்க்கப்படும்போதும் (insertion), அந்த enum ஒரு பொருளாக (object) மாற்றப்படுகிறது. இது தேவையற்ற கூடுதல் சுமையை (overhead) ஏற்படுத்துகிறது.
EnumSet ஒரு bit vector-ஐப் பயன்படுத்துகிறது. இது ஒரு ஒற்றை CPU கட்டளை (instruction) மூலம் சரிபார்ப்புகளைச் செய்கிறது.
- நிலையான enum மதிப்புகள் இருக்கும்போது இதைப் பயன்படுத்தவும்.
- இது garbage collection-ஐக் குறைக்கிறது.
- இது tight loops-களில் 10 மடங்கு வேக அதிகரிப்பை வழங்குகிறது.
Before:
Set<Ability> abilities = new HashSet<>();
abilities.add(Ability.FIRE);
After:
EnumSet<Ability> abilities = EnumSet.of(Ability.FIRE);
- Range Queries-களுக்கு NavigableSet
ஒரு குறிப்பிட்ட வரம்பைக் (range) கண்டறிய வரிசைப்படுத்தப்பட்ட பட்டியலை (sorted list) கைமுறையாக லூப் (loop) செய்வது மெதுவானது மற்றும் பிழைகளுக்கு வழிவகுக்கும். பெரும்பாலும் நீங்கள் off-by-one பிழைகளைச் சந்திக்க நேரிடும்.
NavigableSet உங்கள் தரவை தானாகவே வரிசைப்படுத்தி வைத்திருக்கும். இது subsets-களுக்கான O(log n) தேடல்களை வழங்குகிறது.
- அதிக ஸ்கோர் அட்டவணைகள் அல்லது விலை வரம்புகளுக்கு இதைப் பயன்படுத்தவும்.
- குறிப்பிட்ட வரம்புகளைப் பெற
headSet()அல்லதுsubSet()ஆகியவற்றைப் பயன்படுத்தவும். - இது கைமுறை வரிசைப்படுத்தும் குறியீட்டின் தேவையைக் குறைக்கிறது.
Before:
Collections.sort(scores);
List<Integer> topTen = scores.subList(size - 10, size);
After:
NavigableSet<Integer> scores = new TreeSet<>(Comparator.reverseOrder());
scores.add(1542);
NavigableSet<Integer> topTen = scores.headSet(scores.first(), true).stream().limit(10).collect(Collectors.toCollection(TreeSet::new));
- Read-Heavy Lists-களுக்கு CopyOnWriteArrayList
ArrayList-இல் synchronized blocks-களைப் பயன்படுத்துவது ஒவ்வொரு வாசிப்பையும் (read) மெதுவாக்கும். மேலும், ஒரு thread எழுதும்போது மற்றொரு thread வாசித்தால், அது ConcurrentModificationException-ஐ ஏற்படுத்தும்.
CopyOnWriteArrayList ஒவ்வொரு முறை எழுதப்படும்போதும் (write) அடுக்கின் (array) புதிய நகலை உருவாக்குகிறது. வாசகர்கள் (Readers) அடுக்கின் ஒரு snapshot-ஐப் பார்க்கிறார்கள்.
- event listeners அல்லது configuration settings-களுக்கு இதைப் பயன்படுத்தவும்.
- எழுதுவதை விட வாசிப்பு (reads) அதிகமாக நடக்கும்போது இதைப் பயன்படுத்தவும்.
- இது lock-free வாசிப்புகளை அனுமதிக்கிறது.
Before:
List<String> log = Collections.synchronizedList(new ArrayList<>());
// Iterating here can crash if a writer joins in.
After:
CopyOnWriteArrayList<String> log = new CopyOnWriteArrayList<>();
// Iteration is safe and never crashes.
எப்போதும் ஒரே இரண்டு collections-களையே பயன்படுத்துவதை நிறுத்துங்கள். உங்கள் தரவு அமைப்பிற்கு (data pattern) ஏற்ற கருவியைத் தேர்ந்தெடுங்கள்.
ஆதாரம்: https://dev.to/timevolt/the-java-collections-force-mastering-the-hidden-gems-like-a-jedi-4438