Java Collections: நீங்கள் தவறவிடும் மறைக்கப்பட்ட கருவிகள்

பெரும்பாலான டெவலப்பர்கள் ஒவ்வொரு நாளும் Java collections-ஐ ஒரே மாதிரியாகப் பயன்படுத்துகிறார்கள். அவர்கள் ArrayLists மற்றும் HashSets-ஐப் பயன்படுத்துகிறார்கள். ஆனால் உங்கள் குறியீட்டை (code) வேகமாகவும் பாதுகாப்பாகவும் மாற்றக்கூடிய கருவிகளை நீங்கள் தவறவிடக்கூடும்.

உங்கள் குறியீட்டை மேம்படுத்த இதோ மூன்று குறிப்பிட்ட கருவிகள்.

  1. Arrays.asList என்பது ஒரு உண்மையான List அல்ல

நீங்கள் Arrays.asList(array) என்பதைப் பயன்படுத்தும்போது, உங்களுக்கு ஒரு நிலையான அளவுள்ள (fixed-size) list கிடைக்கிறது. இது உங்கள் அசல் array-உடன் நேரடியாக இணைக்கப்பட்டுள்ளது.

  • நீங்கள் array-ஐ மாற்றினால், list-ம் மாறும்.
  • நீங்கள் உருப்படிகளைச் சேர்க்கவோ அல்லது நீக்கவோ முயன்றால், உங்கள் code பிழையுடன் (error) செயலிழந்துவிடும்.

இதைச் சரிசெய்ய, அதை ஒரு புதிய ArrayList-க்குள் வைக்கவும்: List list = new ArrayList<>(Arrays.asList(array));

இது நீங்கள் மாற்றியமைக்கக்கூடிய ஒரு உண்மையான, சுதந்திரமான list-ஐ உருவாக்குகிறது.

  1. செயல்திறனுக்காக (performance) EnumSet-ஐப் பயன்படுத்தவும்

நீங்கள் enums-ஐ ஒரு HashSet-இல் சேமிக்கிறீர்களா? அது தேவையற்ற கூடுதல் சுமையை (overhead) உருவாக்கும். HashSets, hash tables மற்றும் object headers-ஐப் பயன்படுத்துகின்றன.

அதற்குப் பதிலாக EnumSet-ஐப் பயன்படுத்தவும். இது உட்புறமாக ஒரு bit vector-ஐப் பயன்படுத்துகிறது. இது மிகவும் வேகமானது மற்றும் நினைவகத்தை (memory) மிகக் குறைவாகவே பயன்படுத்துகிறது. பிளேயர் சக்திகள் (player powers) அல்லது அமைப்புகள் (settings) போன்ற flag-அடிப்படையிலான அமைப்புகளுக்கு இது மிகவும் பொருத்தமானது.

  • இது type-safe ஆகும்.
  • இது HashSet-ஐ விட மிகவும் வேகமானது.
  • இது உங்களுக்காக bitwise செயல்பாடுகளைக் கையாள்கிறது.
  1. கேஷ்களுக்காக (caches) ConcurrentHashMap.computeIfAbsent-ஐப் பயன்படுத்தவும்

நீங்கள் ஒரு cache-ஐ உருவாக்கும்போது, பல threads ஒரே மதிப்பைத் திரும்பத் திரும்பக் கணக்கிடுவதைத் தடுக்க பெரும்பாலும் சிக்கலான குறியீட்டை எழுதுவீர்கள். இது double-checked locking என்று அழைக்கப்படுகிறது. இது வாசிப்பதற்கு கடினமானது மற்றும் எளிதில் பிழையடையக்கூடியது.

அதற்குப் பதிலாக, ஒரே ஒரு வரியைப் பயன்படுத்தவும்: cache.computeIfAbsent(key, this::expensiveCalculation);

இந்த முறை atomic ஆகும். பல threads ஒரே நேரத்தில் ஒரே key-ஐக் கேட்டாலும், கணக்கீடு ஒருமுறை மட்டுமே நடப்பதை இது உறுதி செய்கிறது. இது பிழைகளைக் குறைக்கிறது மற்றும் உங்கள் நோக்கத்தைத் தெளிவாகக் காட்டுகிறது.

இந்த கருவிகள் ஏன் முக்கியம்:

  • கணிக்கக்கூடிய செயல்திறன் (Predictable performance): மறைமுகமான நினைவகச் செலவுகளை நீங்கள் தவிர்க்கலாம்.
  • குறைவான பிழைகள்: மல்டி-த்ரெடட் (multi-threaded) குறியீட்டில் race conditions-உடன் போராடுவதைத் தவிர்க்கலாம்.
  • தெளிவான குறியீடு: மற்ற டெவலப்பர்கள் உங்கள் வடிவமைப்பை உடனடியாகப் புரிந்துகொள்வார்கள்.

framework-உடன் போராடுவதை நிறுத்துங்கள். மெலிதான மற்றும் பாதுகாப்பான குறியீட்டை எழுத அதைப் பயன்படுத்தத் தொடங்குங்கள்.

ஆதாரம்: https://dev.to/timevolt/java-collections-the-hidden-relics-most-developers-miss-and-why-theyre-game-changers-4ehd