𝗠𝗮𝘀𝘁𝗲𝗿 𝗝𝗮𝘃𝗮 𝗖𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻𝘀
ಹೆಚ್ಚಿನ ಅಭಿವರ್ಧಕರು (developers) ಸಾಮಾನ್ಯವಾಗಿ ArrayList ಅಥವಾ HashSet ಅನ್ನು ಬಳಸುತ್ತಾರೆ. ಇದು ಸರಳ ಕೆಲಸಗಳಿಗೆ ಸರಿಹೊಂದುತ್ತದೆ. ಆದರೆ ನಿಮಗೆ ವೇಗ ಅಥವಾ ದೊಡ್ಡ ಪ್ರಮಾಣದ ಡೇಟಾ (scale) ಬೇಕಾದಾಗ ಇದು ವಿಫಲವಾಗುತ್ತದೆ.
ನಾನು ಒಮ್ಮೆ ಕೇವಲ ArrayList ಬಳಸಿ ಒಂದು ಗೇಮ್ ಲೀಡರ್ಬೋರ್ಡ್ (game leaderboard) ನಿರ್ಮಿಸಿದ್ದೆ. ಪ್ರತಿ ಬಾರಿ ಸ್ಕೋರ್ ಬದಲಾದಾಗಲೂ ನಾನು ಅದನ್ನು ಸಾರ್ಟ್ (sort) ಮಾಡುತ್ತಿದ್ದೆ. ಇದರಿಂದ UI ಪದೇ ಪದೇ ಫ್ರೀಜ್ ಆಗುತ್ತಿತ್ತು. ನಾನು ಭಾಷೆಯನ್ನು (language) ಬಳಸುವ ಬದಲು ಅದರ ವಿರುದ್ಧ ಹೋರಾಡುತ್ತಿದ್ದೆ.
ತಪ್ಪು ಪರಿಕರಗಳನ್ನು (tools) ಬಳಸುವುದು ನಿಲ್ಲಿಸಿ. ವೇಗವಾದ ಮತ್ತು ಸ್ವಚ್ಛವಾದ ಕೋಡ್ ಬರೆಯಲು ಈ ಮೂರು ವಿಶೇಷ ಕಲೆಕ್ಷನ್ಗಳನ್ನು ಬಳಸಿ.
- Enum Constants ಗಾಗಿ EnumSet
ನೀವು enums ಗಾಗಿ HashSet ಬಳಸಿದರೆ, ನೀವು ಕಾರ್ಯಕ್ಷಮತೆಯ (performance) ದರವನ್ನು ತೆರಬೇಕಾಗುತ್ತದೆ. ಪ್ರತಿ ಇನ್ಸರ್ಶನ್ (insertion) ಕೂಡ enum ಅನ್ನು ಒಂದು ಆಬ್ಜೆಕ್ಟ್ಗೆ ಬದಲಾಯಿಸುತ್ತದೆ. ಇದು ಅನಗತ್ಯ ಹೊರೆಯನ್ನು (overhead) ಉಂಟುಮಾಡುತ್ತದೆ.
EnumSet ಒಂದು bit vector ಅನ್ನು ಬಳಸುತ್ತದೆ. ಇದು ಒಂದೇ CPU ಇನ್ಸ್ಟ್ರಕ್ಷನ್ ಬಳಸಿ ಪರಿಶೀಲನೆಗಳನ್ನು ಮಾಡುತ್ತದೆ.
- ನಿಗದಿತ (fixed) set of enum values ಇದ್ದಾಗ ಇದನ್ನು ಬಳಸಿ.
- ಇದು garbage collection ಅನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
- ಇದು tight loops ನಲ್ಲಿ 10x ವೇಗವನ್ನು ನೀಡುತ್ತದೆ.
Before:
Set<Ability> abilities = new HashSet<>();
abilities.add(Ability.FIRE);
After:
EnumSet<Ability> abilities = EnumSet.of(Ability.FIRE);
- Range Queries ಗಾಗಿ NavigableSet
ಒಂದು ರೇಂಜ್ ಅನ್ನು ಹುಡುಕಲು ಸಾರ್ಟ್ ಮಾಡಲಾದ ಲಿಸ್ಟ್ ಮೂಲಕ ಮ್ಯಾನುಯಲ್ ಆಗಿ ಲೂಪ್ ಮಾಡುವುದು ನಿಧಾನ ಮತ್ತು ದೋಷಗಳಿಗೆ (errors) ಒಳಗಾಗುವ ಸಾಧ್ಯತೆ ಇರುತ್ತದೆ. ಇದರಿಂದ ಹೆಚ್ಚಾಗಿ 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 ಬ್ಲಾಕ್ಗಳನ್ನು ಬಳಸುವುದು ಪ್ರತಿ ರೀಡ್ (read) ಅನ್ನು ನಿಧಾನಗೊಳಿಸುತ್ತದೆ. ಒಂದು ಥ್ರೆಡ್ ಬರೆಯುತ್ತಿರುವಾಗ ಇನ್ನೊಂದು ಥ್ರೆಡ್ ಓದುತ್ತಿದ್ದರೆ, ಇದು ConcurrentModificationException ಅನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ.
CopyOnWriteArrayList ಪ್ರತಿ ಬರೆಯುವಿಕೆಯಲ್ಲಿ (write) ಅರೇಯಿನ ಹೊಸ ಪ್ರತಿಯನ್ನು (copy) ರಚಿಸುತ್ತದೆ. ರೀಡರ್ಗಳು ಅರೇಯಿನ ಸ್ನ್ಯಾಪ್ಶಾಟ್ ಅನ್ನು ನೋಡುತ್ತಾರೆ.
- ಇವೆಂಟ್ ಲಿಸನರ್ಗಳು (event listeners) ಅಥವಾ ಕಾನ್ಫಿಗರೇಶನ್ ಸೆಟ್ಟಿಂಗ್ಗಳಿಗಾಗಿ ಇದನ್ನು ಬಳಸಿ.
- ಬರೆಯುವುದಕ್ಕಿಂತ ಓದುವುದು (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 ಗೆ ಹೊಂದಿಕೆಯಾಗುವ tool ಅನ್ನು ಆರಿಸಿ.
ಮೂಲ: https://dev.to/timevolt/the-java-collections-force-mastering-the-hidden-gems-like-a-jedi-4438