సేకరణలను ఉపయోగించడంపై చిట్కాలు

1. సేకరణల జాబితా

మీకు గుర్తున్నట్లుగా, జావాలో సేకరణలు ఉన్నాయి - ఒకే రకమైన వస్తువులను నిల్వ చేయడానికి సులభ సాధనం.

ప్రధాన సేకరణ-సంబంధిత ఇంటర్‌ఫేస్‌లను రీకాల్ చేయడానికి ప్రయత్నిద్దాం:

జాబితా , సెట్ , మ్యాప్ మరియు క్యూ .

ఎప్పటిలాగే, సాధనాలు తప్పనిసరిగా మంచివి లేదా చెడ్డవి కావు - మీరు వాటిని ఉద్దేశించిన ప్రయోజనం కోసం ఉపయోగిస్తున్నారా అనేది ముఖ్యం. మరియు అలా చేయడానికి, ఏ సేకరణ మరియు ఎప్పుడు ఉపయోగించాలో తెలుసుకోవడానికి మేము వాటి నిర్దిష్ట లక్షణాలను పూర్తిగా అర్థం చేసుకోవాలి.

1. జాబితా

ఎక్కువగా ఉపయోగించే సేకరణతో ప్రారంభిద్దాం.

సాదా పాత శ్రేణికి వీలైనంత దగ్గరగా జాబితా చేయండి .

ఈ సేకరణ మనం శ్రేణిని ఉపయోగిస్తుంటే, సేకరణ పరిమాణం గురించి చింతించకుండా ఒకే రకమైన వస్తువుల జాబితాను సౌకర్యవంతంగా నిల్వ చేయడానికి అనుమతిస్తుంది. సేకరణ యొక్క మూలకాలు సూచిక ద్వారా యాక్సెస్ చేయబడతాయి. ఆబ్జెక్ట్ ఎక్కడ ఉందో మనకు ఖచ్చితంగా తెలిస్తే మరియు ఎలిమెంట్‌లను జోడించడం లేదా తీసివేయడం అవసరం లేకుండా తరచుగా దాన్ని యాక్సెస్ చేయాల్సి వస్తే, జాబితా అనువైనది .

2. సెట్

సెట్ పూర్తిగా భిన్నమైన నిర్మాణాన్ని కలిగి ఉంది.

మేము ప్రత్యేకమైన వస్తువులను నిల్వ చేయవలసి వచ్చినప్పుడు సెట్ చాలా అనుకూలంగా ఉంటుంది. ఉదాహరణకు, ప్రతి రచయిత ప్రత్యేకంగా ఉండే లైబ్రరీలోని రచయితల సమితి. కానీ మేము వెళ్లి దాని నుండి ఏదైనా నిర్దిష్ట రచయితని పట్టుకోలేము. ఒక నిర్దిష్ట రచయిత మన లైబ్రరీలో ఉన్నారో లేదో త్వరగా తనిఖీ చేయడానికి సెట్ అనుమతిస్తుంది, అనగా సెట్‌లో ప్రత్యేకమైన వస్తువు ఉందో లేదో తనిఖీ చేయవచ్చు. మేము మొత్తం సేకరణను కూడా పునరావృతం చేయవచ్చు, ప్రతి మూలకాన్ని యాక్సెస్ చేయవచ్చు, కానీ అలా చేయడం సరైనది కాదు.

మరో మాటలో చెప్పాలంటే, మా లైబ్రరీ కోసం, ఏదైనా నిర్దిష్ట రచయిత ఉన్నారా అని శీఘ్రంగా తనిఖీ చేయడానికి ఒక సెట్ అన్ని ప్రత్యేక రచయితల సేకరణను సూచిస్తుంది.

3. మ్యాప్

మ్యాప్ అనేది ఫైలింగ్ క్యాబినెట్ లాగా ఉంటుంది, ఇక్కడ ప్రతి ఫైల్ సంతకం చేయబడుతుంది మరియు వ్యక్తిగత వస్తువులు లేదా మొత్తం నిర్మాణాలను నిల్వ చేయవచ్చు. మేము ఒక విలువ నుండి మరొకదానికి మ్యాపింగ్‌ను నిర్వహించాల్సిన సందర్భాలలో మ్యాప్‌ని ఉపయోగించాలి.

మ్యాప్ కోసం , ఈ సంబంధాలను కీ-విలువ జతల అంటారు.

రచయిత వస్తువులను కీలుగా మరియు పుస్తకాల జాబితాలను ( జాబితా వస్తువులు) విలువలుగా ఉపయోగించడం ద్వారా మన లైబ్రరీలో ఈ నిర్మాణాన్ని ఉపయోగించవచ్చు. అందువల్ల, లైబ్రరీలో రచయిత వస్తువు ఉందో లేదో చూడటానికి సెట్‌ను తనిఖీ చేసిన తర్వాత , మ్యాప్ నుండి అతని లేదా ఆమె పుస్తకాల జాబితాను పొందడానికి మేము అదే రచయిత వస్తువును ఉపయోగించవచ్చు .

4. క్యూ

క్యూ అనేది ఒక సేకరణ - ఆశ్చర్యం! - క్యూ యొక్క ప్రవర్తనను అమలు చేస్తుంది. మరియు క్యూ LIFO (లాస్ట్ ఇన్, ఫస్ట్ అవుట్) లేదా FIFO (ఫస్ట్ ఇన్, ఫస్ట్ అవుట్)కావచ్చుఇంకా ఏమిటంటే, క్యూ ద్విదిశాత్మకంగా లేదా "డబుల్-ఎండ్"గా ఉండవచ్చు.

తరగతికి జోడించిన వస్తువులు అందుకున్న క్రమంలో ఉపయోగించాల్సిన అవసరం వచ్చినప్పుడు ఈ నిర్మాణం సహాయపడుతుంది. ఉదాహరణకు, మా లైబ్రరీని తీసుకోండి.

మేము కొత్తగా వచ్చిన సందర్శకులను క్యూలో చేర్చవచ్చు మరియు వారికి అందించే పుస్తకాలను అందజేస్తాము.

మనం చూడగలిగినట్లుగా, ఈ నిర్మాణాలలో ప్రతి ఒక్కటి దాని ఉద్దేశించిన ప్రయోజనం కోసం ఉపయోగించినట్లయితే మంచిది. మరియు మేము ఒకే లైబ్రరీ ఉదాహరణలో మొత్తం నాలుగు రకాల సేకరణలకు మంచి ఉపయోగాలను కనుగొన్నాము.

2. సంక్లిష్టత

ఇప్పటికే గుర్తించినట్లుగా, మేము పైన పరిగణించిన సేకరణలు ఇంటర్‌ఫేస్‌లు, అంటే మనం వాటిని ఉపయోగించాలంటే అవి తప్పనిసరిగా అమలులను కలిగి ఉండాలి.

మైక్రోస్కోప్‌తో గోళ్లను కొట్టడం ఉత్తమమైన ఆలోచన కానట్లే, సేకరణ యొక్క ప్రతి అమలు ప్రతి పరిస్థితికి సరిపోదు.

ఉద్యోగం కోసం సరైన సాధనాన్ని ఎంచుకున్నప్పుడు, మేము సాధారణంగా 2 లక్షణాలను పరిశీలిస్తాము:

• పనికి సాధనం ఎంతవరకు సరిపోతుంది?
• ఇది ఎంత వేగంగా పనిని పూర్తి చేస్తుంది?

ఉద్యోగం కోసం తగిన సాధనాన్ని ఎలా ఎంచుకోవాలో మేము కొంత సమయం గడిపాము, కానీ దాని వేగం కొత్తది.

కంప్యూటింగ్‌లో, సాధనం యొక్క వేగం తరచుగా సమయ సంక్లిష్టత పరంగా వ్యక్తీకరించబడుతుంది మరియు పెద్ద అక్షరం O ద్వారా సూచించబడుతుంది.

ప్రపంచంలో సమయం సంక్లిష్టత ఏమిటి?

సాధారణ పదాలలో, సమయ సంక్లిష్టత నిర్దిష్ట చర్యను (ఒక మూలకాన్ని జోడించడం/తీసివేయడం, మూలకం కోసం శోధించడం) చేయడానికి సేకరణలోని అల్గారిథమ్‌కు అవసరమైన సమయాన్ని సూచిస్తుంది.

అర్రేలిస్ట్ vs లింక్డ్‌లిస్ట్

జాబితా ఇంటర్‌ఫేస్ యొక్క రెండు అమలులను ఉపయోగించి దీన్ని చూద్దాం - అర్రేలిస్ట్ మరియు లింక్డ్‌లిస్ట్ .

బాహ్య ప్రదర్శనల కోసం, ఈ సేకరణలతో పని చేయడం సారూప్యంగా ఉంటుంది:

List<String> arrayList = new ArrayList<>();
arrayList.add(String);
arrayList.get(index);
arrayList.remove(index);
arrayList.remove(String);
 
List<String> linkedList = new LinkedList<>();
 
linkedList.add(String);
 
linkedList.get(index);
linkedList.remove(index);
linkedList.remove(String);
    

మీరు చూడగలిగినట్లుగా, రెండు సేకరణ రకాలకు, ఎలిమెంట్‌లను జోడించడం, పొందడం మరియు తీసివేయడం ఒకేలా కనిపిస్తుంది. ఎందుకంటే ఇవి ఒకే ఇంటర్‌ఫేస్‌లో అమలు చేయబడినవి. కానీ అక్కడ సారూప్యతలు ముగుస్తాయి.

జాబితా ఇంటర్‌ఫేస్ యొక్క విభిన్న అమలుల కారణంగా , ఈ రెండు నిర్మాణాలు ఇతర వాటి కంటే విభిన్న చర్యలను మరింత సమర్థవంతంగా నిర్వహిస్తాయి.

ఒక మూలకాన్ని తీసివేసి, జోడించడాన్ని పరిగణించండి.

మేము అర్రేలిస్ట్ మధ్య నుండి ఒక మూలకాన్ని తీసివేయవలసి వస్తే , మనం తీసివేసిన మూలకాన్ని అనుసరించే జాబితాలోని ఏ భాగాన్ని అయినా ఓవర్‌రైట్ చేయాలి.

మనకు 5 మూలకాల జాబితా ఉంది మరియు మేము 3వదాన్ని తీసివేయాలనుకుంటున్నాము.

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
list.remove(2);
    

ఈ సందర్భంలో, తీసివేత ఒక సెల్‌ను ఖాళీ చేస్తుంది, కాబట్టి మనం 4వ మూలకాన్ని 3వ స్థానంలో మరియు 5వ మూలకాన్ని 4వ స్థానంలో వ్రాయాలి.

ఇది చాలా అసమర్థమైనది.

జాబితా మధ్యలో ఒక మూలకాన్ని జోడించేటప్పుడు అదే జరుగుతుంది.

లింక్డ్‌లిస్ట్ విభిన్నంగా రూపొందించబడింది. మూలకాలను జోడించడం లేదా తీసివేయడం వేగంగా జరుగుతుంది, ఎందుకంటే మనం మునుపటి మరియు తదుపరి మూలకాలలోని సూచనలను మాత్రమే మార్చాలి, తద్వారా మూలకాల గొలుసు నుండి మనం తీసివేసిన వస్తువును మినహాయించాలి.

5 మూలకాల యొక్క అదే జాబితా యొక్క ఉదాహరణకి తిరిగి, 3వ మూలకాన్ని తీసివేసిన తర్వాత, మనం చేయాల్సిందల్లా 2వ మూలకం యొక్క సూచనను తదుపరి మూలకానికి మరియు 4వ మూలకం యొక్క సూచనను మునుపటి దానికి మార్చడం మాత్రమే.

జాబితాకు మూలకం జోడించబడినప్పుడు, అదే ప్రక్రియ జరుగుతుంది, కానీ రివర్స్‌లో.

అర్రేలిస్ట్‌తో పోల్చితే లింక్డ్‌లిస్ట్‌లో మనం ఎంత తక్కువ పని చేయాల్సి ఉంటుందో గమనించండి . మరియు అది కేవలం 5 అంశాలు. మా జాబితాలో 100 లేదా అంతకంటే ఎక్కువ అంశాలు ఉంటే, లింక్డ్‌లిస్ట్ యొక్క ఆధిక్యత మరింత గుర్తించదగినదిగా మారుతుంది.

అయితే మనం ఇండెక్స్ ద్వారా మూలకాన్ని యాక్సెస్ చేస్తే పరిస్థితి ఎలా మారుతుంది?

ఇక్కడ ప్రతిదీ సరిగ్గా వ్యతిరేకం.

ArrayList ఒక సాధారణ శ్రేణి వలె నిర్మించబడినందున, దాని సూచిక ద్వారా ఏదైనా మూలకాన్ని పొందడం మాకు చాలా సులభం. మేము పాయింటర్‌ను ఒక నిర్దిష్ట ప్రదేశానికి తరలించి, సంబంధిత సెల్ నుండి మూలకాన్ని పొందుతాము.

కానీ లింక్డ్‌లిస్ట్ ఆ విధంగా పని చేయదు. నిర్దిష్ట సూచికతో మూలకాన్ని కనుగొనడానికి మేము జాబితాలోని అన్ని మూలకాల ద్వారా వెళ్లాలి.

వీటన్నింటిని పెద్ద ఓ పరంగా వ్యక్తీకరించడానికి ప్రయత్నిస్తామా?

ఇండెక్స్ ద్వారా మూలకాన్ని యాక్సెస్ చేయడం ద్వారా ప్రారంభిద్దాం.

అర్రేలిస్ట్‌లో , లిస్ట్‌లో మూలకం ఎక్కడ ఉందో దానితో సంబంధం లేకుండా ఇది ఒక దశలో జరుగుతుంది . చివరిలో అయినా, ప్రారంభంలో అయినా.

ఈ సందర్భంలో, సమయ సంక్లిష్టత O(1) అవుతుంది .

లింక్డ్‌లిస్ట్‌లో , మనకు అవసరమైన సూచిక విలువకు సమానమైన అనేక మూలకాలపై మనం పునరావృతం చేయాలి.

అటువంటి చర్య యొక్క సమయ సంక్లిష్టత O(n) , ఇక్కడ n అనేది మనకు అవసరమైన మూలకం యొక్క సూచిక.

మేము పెద్ద-O కుండలీకరణాల్లో ఉంచిన సంఖ్య చేసిన చర్యల సంఖ్యకు అనుగుణంగా ఉన్నట్లు ఇక్కడ మీరు చూస్తారు.

షెల్ మేము తీసివేసి జోడించాలా?

లింక్డ్‌లిస్ట్‌తో ప్రారంభిద్దాం.

మూలకాన్ని జోడించడానికి లేదా తీసివేయడానికి మేము పెద్ద సంఖ్యలో చర్యలు చేయనవసరం లేదు, మరియు ఈ ఆపరేషన్ యొక్క వేగం మూలకం ఉన్న ప్రదేశంపై ఏ విధంగానూ ఆధారపడి ఉండదు, దీని సంక్లిష్టత O(1)గా వ్యక్తీకరించబడుతుంది మరియు చెప్పబడింది స్థిరంగా ఉండాలి.

ArrayList కోసం ఈ ఆపరేషన్ యొక్క సమయ సంక్లిష్టత కూడా O(n) , దీనిని మేము సరళ సంక్లిష్టత అని పిలుస్తాము.

సరళ సంక్లిష్టతతో అల్గోరిథంలలో, నడుస్తున్న సమయం నేరుగా ప్రాసెస్ చేయవలసిన మూలకాల సంఖ్యపై ఆధారపడి ఉంటుంది. ఇది మూలకం యొక్క స్థానంపై కూడా ఆధారపడి ఉండవచ్చు, ఇది జాబితా ప్రారంభంలో లేదా ముగింపులో ఉంటుంది.

సమయ సంక్లిష్టత కూడా లాగరిథమిక్ కావచ్చు. ఇది O(log n) గా వ్యక్తీకరించబడింది .

ఉదాహరణగా, 10 సంఖ్యలతో కూడిన క్రమబద్ధీకరించబడిన ట్రీసెట్‌ను పరిగణించండి. మేము 2 సంఖ్యను కనుగొనాలనుకుంటున్నాము.

జాబితా క్రమబద్ధీకరించబడినందున మరియు నకిలీలను కలిగి లేనందున, మేము దానిని సగానికి విభజించి, ఏ సగం కావలసిన సంఖ్యను కలిగి ఉందో తనిఖీ చేయవచ్చు, అసంబద్ధమైన భాగాన్ని విస్మరించి, మేము కోరుకున్న మూలకాన్ని చేరుకునే వరకు ఈ విధానాన్ని పునరావృతం చేయవచ్చు. అంతిమంగా, లాగ్ (n) మూలకాల సంఖ్యను ప్రాసెస్ చేసిన తర్వాత మేము సంఖ్యను కనుగొంటాము (లేదా కనుగొనలేము).

మిగిలిన సేకరణల సమయ సంక్లిష్టతను సంగ్రహించే పట్టిక ఇక్కడ ఉంది.

ఇప్పుడు మేము జనాదరణ పొందిన సేకరణల సమయ సంక్లిష్టతను చూపే పట్టికను కలిగి ఉన్నాము, చాలా సేకరణలలో, మేము తరచుగా ArrayList , HashSet మరియు HashMap లను ఎందుకు ఉపయోగిస్తాము అనే ప్రశ్నకు సమాధానం ఇవ్వగలము .

అవి చాలా పనులకు అత్యంత ప్రభావవంతంగా ఉంటాయి :)