కాపీఆన్ రైట్అర్రేలిస్ట్
అందించిన సేకరణలో జోడింపు , సెట్ , తీసివేయి కార్యకలాపాల ఫలితంగా అంతర్గత శ్రేణి యొక్క కొత్త కాపీ సృష్టించబడుతుంది. మేము ConcurrentModificationExceptionని పట్టుకోలేమని ఇది నిర్ధారిస్తుంది .
శ్రేణిని కాపీ చేస్తున్నప్పుడు, థ్రెడ్-సురక్షిత మూలకాల యొక్క ఫీల్డ్‌లకు యాక్సెస్‌తో సహా వస్తువులకు సంబంధించిన సూచనలు మాత్రమే కాపీ చేయబడతాయని గుర్తుంచుకోండి. కనిష్ట సంఖ్యలో వ్రాత కార్యకలాపాలు ఉన్న సందర్భాల్లో ఇటువంటి సేకరణలు ఉత్తమంగా ఉపయోగించబడతాయి.
CopyOnWriteArrayList<E> అనేది ArrayList యొక్క థ్రెడ్-సురక్షిత అనలాగ్, ఇది CopyOnWrite అల్గారిథమ్‌ల ఆధారంగా అమలు చేయబడుతుంది. అదనపు పద్ధతులు మరియు కన్స్ట్రక్టర్ క్రింద వివరించబడ్డాయి:
| CopyOnWriteArrayList(E[] toCopyIn) | శ్రేణిని ఇన్‌పుట్‌గా తీసుకునే కన్స్ట్రక్టర్. |
| int indexOf(E e, int ఇండెక్స్) | ఇవ్వబడిన సూచిక నుండి ప్రారంభించి, కనుగొనబడిన మొదటి మూలకం యొక్క సూచికను అందిస్తుంది. |
| int lastIndexOf(E e, int ఇండెక్స్) | ఇవ్వబడిన సూచిక నుండి ప్రారంభించి, రివర్స్ శోధనలో కనుగొనబడిన మొదటి మూలకం యొక్క సూచికను అందిస్తుంది. |
| బూలియన్ addIfAbsent(E e) | మూలకం సేకరణలో లేకుంటే దానిని జోడించండి. మూలకాలను పోల్చడానికి సమాన పద్ధతి ఉపయోగించబడుతుంది . |
| int addAllAbsent(సేకరణ<? పొడిగిస్తుంది E> c) | మూలకాలు సేకరణలో లేకుంటే వాటిని జోడించండి. జోడించిన మూలకాల సంఖ్యను అందిస్తుంది. |
ConcurrentMap ఇంటర్‌ఫేస్
మల్టీథ్రెడింగ్ మరియు స్కేలబిలిటీకి మద్దతుతో HashMap మరియు TreeMap యొక్క మెరుగైన అమలులు .
ConcurrentMap<K, V> అనేది అదనపు పరమాణు కార్యకలాపాలతో మ్యాప్‌ను విస్తరించే ఇంటర్‌ఫేస్
| V putIfAbsent(K కీ, V విలువ) | కీ సేకరణలో లేకుంటే మాత్రమే కొత్త కీ-విలువ జతని జోడిస్తుంది. ఇచ్చిన కీ కోసం మునుపటి విలువను అందిస్తుంది. |
| బూలియన్ తొలగించు (ఆబ్జెక్ట్ కీ, ఆబ్జెక్ట్ విలువ) | ఇచ్చిన కీ మ్యాప్‌లో ఇవ్వబడిన విలువతో సరిపోలితే మాత్రమే కీ-విలువ జతని తొలగిస్తుంది. మూలకం విజయవంతంగా తీసివేయబడితే ఒప్పు అని చూపబడుతుంది. |
| బూలియన్ రీప్లేస్ (K కీ, V పాత విలువ, V కొత్త విలువ) | మ్యాప్‌లో ఇచ్చిన విలువతో పాత విలువ సరిపోలితే మాత్రమే పాత విలువను కొత్త దానితో కీతో భర్తీ చేస్తుంది. విలువ కొత్త దానితో భర్తీ చేయబడి ఉంటే నిజం చూపబడుతుంది. |
| V భర్తీ (K కీ, V విలువ) | కీ ఏదైనా విలువతో అనుబంధించబడి ఉంటే మాత్రమే పాత విలువను కొత్త దానితో కీతో భర్తీ చేస్తుంది. ఇచ్చిన కీ కోసం మునుపటి విలువను అందిస్తుంది. |
ConcurrentHashMap<K, V> - ఇక్కడ డేటా విభాగాల రూపంలో ప్రదర్శించబడుతుంది, ఇవి కీ హ్యాష్‌లుగా విభజించబడ్డాయి. ఫలితంగా, మీకు యాక్సెస్ అవసరమైతే, సెగ్మెంట్ లాక్ చేయబడింది, వస్తువు కాదు. ఇటరేటర్లు ConcurrentModificationExceptionని త్రోసివేయవుమరియు నిర్దిష్ట సమయం కోసం డేటాను సూచిస్తాయి.
ConcurrentHashMap యొక్క అమలులు
ConcurrentHashMap<K, V> - ఇక్కడ డేటా విభాగాల రూపంలో ప్రదర్శించబడుతుంది, కీ హ్యాష్‌ల ద్వారా విభజించబడింది. ఫలితంగా, డేటా యాక్సెస్ ఒక వస్తువు ద్వారా కాకుండా విభాగాల ద్వారా లాక్ చేయబడింది. అదనంగా, ఇటరేటర్లు నిర్దిష్ట సమయం కోసం డేటాను సూచిస్తాయి మరియు ConcurrentModificationException త్రో చేయవద్దు .
ConcurrentNavigableMap<K,V> - నావిగేబుల్ మ్యాప్ ఇంటర్‌ఫేస్‌ను విస్తరిస్తుందిమరియు కాన్‌కరెంట్ నావిగేబుల్ మ్యాప్‌ను అందిస్తుంది . అన్ని ఇటరేటర్లు ఉపయోగించడానికి సురక్షితం మరియు ConcurrentModificationExceptionని త్రో చేయవద్దు.
ConcurrentSkipListMap<K, V> అనేది మల్టీథ్రెడింగ్ కోసం TreeMap యొక్క అనలాగ్. డేటా కీ ద్వారా క్రమబద్ధీకరించబడుతుంది మరియుకలిగి ఉన్న కీ,గెట్,పుట్,రిమూవ్మరియు ఇతర సారూప్య కార్యకలాపాలకు సగటు లాగ్ (N) పనితీరు హామీ ఇవ్వబడుతుంది.
ConcurrentSkipListSet<E> అనేది ConcurrentSkipListMap ఆధారంగా సెట్ ఇంటర్‌ఫేస్ యొక్క అమలు.