𝗝𝗮𝘃𝗮 𝗖𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻𝘀: 𝗧𝗵𝗲 𝗛𝗶𝗱𝗱𝗲𝗻 𝗧𝗼𝗼𝗹𝘀 𝗬𝗼𝘂 𝗠𝗶𝘀𝘀

മിക്ക ഡെവലപ്പർമാരും എല്ലാ ദിവസവും ഒരേ രീതിയിൽ തന്നെയാണ് Java collections ഉപയോഗിക്കുന്നത്. അവർ ArrayLists-ഉം HashSets-ഉം ആണ് ഉപയോഗിക്കുന്നത്. എന്നാൽ നിങ്ങളുടെ കോഡ് കൂടുതൽ വേഗതയുള്ളതും സുരക്ഷിതവുമാക്കാൻ സഹായിക്കുന്ന ചില ടൂളുകൾ നിങ്ങൾ ശ്രദ്ധിക്കാതെ പോയേക്കാം.

നിങ്ങളുടെ കോഡ് മെച്ചപ്പെടുത്തുന്നതിനായുള്ള മൂന്ന് പ്രത്യേക ടൂളുകൾ താഴെ പറയുന്നവയാണ്.

  1. Arrays.asList ഒരു യഥാർത്ഥ List അല്ല

നിങ്ങൾ Arrays.asList(array) ഉപയോഗിക്കുമ്പോൾ, നിങ്ങൾക്ക് ലഭിക്കുന്നത് ഒരു fixed-size list ആണ്. ഇത് നിങ്ങളുടെ ഒറിജിനൽ array-യുമായി നേരിട്ട് ബന്ധപ്പെട്ടിരിക്കുന്നു.

  • നിങ്ങൾ array മാറ്റിയാൽ, list-ഉം മാറുന്നു.
  • നിങ്ങൾ ഐറ്റങ്ങൾ ചേർക്കാൻ (add) അല്ലെങ്കിൽ നീക്കം ചെയ്യാൻ (remove) ശ്രമിച്ചാൽ, ഒരു error വന്ന് കോഡ് ക്രാഷ് ആകും.

ഇത് പരിഹരിക്കാൻ, അതിനെ ഒരു പുതിയ ArrayList-ൽ ഉൾപ്പെടുത്തുക: List list = new ArrayList<>(Arrays.asList(array));

ഇത് നിങ്ങൾക്ക് മാറ്റങ്ങൾ വരുത്താൻ കഴിയുന്ന ഒരു യഥാർത്ഥ, സ്വതന്ത്രമായ list നിർമ്മിക്കുന്നു.

  1. മികച്ച പെർഫോമൻസിനായി EnumSet ഉപയോഗിക്കുക

നിങ്ങൾ enums ഒരു HashSet-ൽ ആണ് സൂക്ഷിക്കുന്നത്? അത് അനാവശ്യമായ overhead ഉണ്ടാക്കുന്നു. HashSets ഉപയോഗിക്കുന്നത് hash tables-ഉം object headers-ഉം ആണ്.

പകരം EnumSet ഉപയോഗിക്കുക. ഇത് ആന്തരികമായി ഒരു bit vector ആണ് ഉപയോഗിക്കുന്നത്. ഇത് വളരെ വേഗതയുള്ളതും ഏതാണ്ട് മെമ്മറി ഒട്ടും ഉപയോഗിക്കാത്തതുമാണ്. പ്ലെയർ പവേഴ്സ് (player powers) അല്ലെങ്കിൽ സെറ്റിംഗ്സ് (settings) പോലുള്ള flag-അധിഷ്ഠിത സിസ്റ്റങ്ങൾക്ക് ഇത് അനുയോജ്യമാണ്.

  • ഇത് type-safe ആണ്.
  • ഇത് ഒരു HashSet-നേക്കാൾ വളരെ വേഗതയുള്ളതാണ്.
  • ഇത് bitwise operations നിങ്ങൾക്കായി കൈകാര്യം ചെയ്യുന്നു.
  1. കാഷുകൾക്കായി (caches) ConcurrentHashMap.computeIfAbsent ഉപയോഗിക്കുക

നിങ്ങൾ ഒരു cache നിർമ്മിക്കുകയാണെങ്കിൽ, ഒന്നിലധികം threads ഒരേ മൂല്യം (value) വീണ്ടും കണക്കാക്കുന്നത് തടയാൻ പലപ്പോഴും സങ്കീർണ്ണമായ കോഡുകൾ എഴുതാറുണ്ട്. ഇതിനെ double-checked locking എന്ന് വിളിക്കുന്നു. ഇത് വായിക്കാൻ പ്രയാസമുള്ളതും എളുപ്പത്തിൽ പിഴവുകൾ സംഭവിക്കാവുന്നതുമാണ്.

പകരം, ഒരു വരി മാത്രം ഉപയോഗിക്കുക: cache.computeIfAbsent(key, this::expensiveCalculation);

ഈ മെത്തേഡ് atomic ആണ്. ഒരേ സമയം പല threads ഒരേ key ആവശ്യപ്പെട്ടാലും, കണക്കുകൂട്ടൽ (calculation) ഒരു തവണ മാത്രമേ നടക്കുന്നുള്ളൂ എന്ന് ഇത് ഉറപ്പാക്കുന്നു. ഇത് ബഗുകൾ കുറയ്ക്കുകയും നിങ്ങളുടെ ഉദ്ദേശ്യം വ്യക്തമാക്കുകയും ചെയ്യുന്നു.

ഈ ടൂളുകൾ പ്രധാനമായിരിക്കുന്നത് എന്തുകൊണ്ട്:

  • പ്രവചിക്കാവുന്ന പെർഫോമൻസ് (Predictable performance): ഒളിഞ്ഞിരിക്കുന്ന മെമ്മറി ചിലവുകൾ ഒഴിവാക്കാം.
  • കുറഞ്ഞ ബഗുകൾ: മൾട്ടി-ത്രെഡഡ് (multi-threaded) കോഡിലെ race conditions ഒഴിവാക്കാം.
  • വ്യക്തമായ കോഡ്: മറ്റ് ഡെവലപ്പർമാർക്ക് നിങ്ങളുടെ ഡിസൈൻ പെട്ടെന്ന് മനസ്സിലാകും.

ഫ്രെയിംവർക്കിനോട് പൊരുതുന്നത് നിർത്തുക. കൂടുതൽ ലളിതവും സുരക്ഷിതവുമായ കോഡ് എഴുതാൻ അത് ഉപയോഗിച്ചു തുടങ്ങുക.

Source: https://dev.to/timevolt/java-collections-the-hidden-relics-most-developers-miss-and-why-theyre-game-changers-4ehd