𝗝𝗮𝘃𝗮 𝗖𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻𝘀: మీరు గమనించని రహస్య సాధనాలు

చాలా మంది డెవలపర్లు ప్రతిరోజూ Java collections ను ఒకే విధంగా ఉపయోగిస్తారు. వారు ArrayLists మరియు HashSets ఉపయోగిస్తారు. కానీ మీ కోడ్‌ను వేగంగా మరియు సురక్షితంగా మార్చే సాధనాలను మీరు వదిలివేస్తూ ఉండవచ్చు.

మీ కోడ్‌ను మెరుగుపరచడానికి ఇక్కడ మూడు ప్రత్యేకమైన సాధనాలు ఉన్నాయి.

  1. Arrays.asList అనేది నిజమైన List కాదు

మీరు Arrays.asList(array) ఉపయోగించినప్పుడు, మీకు ఒక fixed-size list లభిస్తుంది. ఇది నేరుగా మీ అసలు arrayకి అనుసంధానించబడి ఉంటుంది.

  • మీరు arrayని మారిస్తే, list కూడా మారుతుంది.
  • మీరు ఐటమ్స్‌ను జోడించడానికి లేదా తొలగించడానికి ప్రయత్నిస్తే, మీ కోడ్ ఎర్రర్‌తో క్రాష్ అవుతుంది.

దీనిని సరిచేయడానికి, దానిని కొత్త ArrayListలో wrap చేయండి: List<String> list = new ArrayList<>(Arrays.asList(array));

ఇది మీరు మార్చుకోగలిగే నిజమైన, స్వతంత్ర listని సృష్టిస్తుంది.

  1. పనితీరు (performance) కోసం EnumSet ఉపయోగించండి

మీరు enums ను HashSetలో నిల్వ చేస్తున్నారా? అది అనవసరమైన overheadని కలిగిస్తుంది. HashSets, hash tables మరియు object headersలను ఉపయోగిస్తాయి.

దానికి బదులుగా EnumSet ఉపయోగించండి. ఇది అంతర్గతంగా ఒక bit vectorని ఉపయోగిస్తుంది. ఇది చాలా వేగంగా ఉంటుంది మరియు దాదాపు మెమరీని ఉపయోగించదు. ప్లేయర్ పవర్స్ లేదా సెట్టింగ్స్ వంటి flag-based సిస్టమ్స్‌కు ఇది సరిగ్గా సరిపోతుంది.

  • ఇది type-safe.
  • ఇది HashSet కంటే చాలా వేగంగా ఉంటుంది.
  • ఇది మీ కోసం bitwise operationsలను నిర్వహిస్తుంది.
  1. caches కోసం ConcurrentHashMap.computeIfAbsent ఉపయోగించండి

మీరు ఒక cacheని నిర్మిస్తున్నప్పుడు, బహుళ threads ఒకే విలువను లెక్కించకుండా నిరోధించడానికి తరచుగా సంక్లిష్టమైన కోడ్‌ను రాస్తారు. దీనిని double-checked locking అంటారు. ఇది చదవడానికి కష్టంగా ఉంటుంది మరియు తప్పులు జరగడానికి అవకాశం ఉంది.

దానికి బదులుగా, కేవలం ఒకే లైన్ ఉపయోగించండి: cache.computeIfAbsent(key, this::expensiveCalculation);

ఈ method అనేది atomic. చాలా threads ఒకే సమయంలో ఒకే key కోసం అడిగినా, లెక్క (calculation) కేవలం ఒక్కసారి మాత్రమే జరుగుతుందని ఇది నిర్ధారిస్తుంది. ఇది బగ్‌లను తగ్గిస్తుంది మరియు మీ ఉద్దేశాన్ని స్పష్టంగా తెలియజేస్తుంది.

ఈ సాధనాలు ఎందుకు ముఖ్యమైనవి:

  • ఊహించదగిన పనితీరు (Predictable performance): మీరు దాగి ఉన్న మెమరీ ఖర్చులను నివారించవచ్చు.
  • తక్కువ బగ్‌లు: మల్టీ-థ్రెడెడ్ కోడ్‌లో race conditionsతో పోరాడటం ఆపవచ్చు.
  • స్పష్టమైన కోడ్: ఇతర డెవలపర్లు మీ డిజైన్‌ను వెంటనే అర్థం చేసుకుంటారు.

ఫ్రేమ్‌వర్క్‌తో పోరాడటం ఆపండి. మరింత lean మరియు సురక్షితమైన కోడ్‌ను రాయడానికి దానిని ఉపయోగించడం ప్రారంభించండి.

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