జావా ప్రోగ్రామింగ్ భాష ఆప్టిమైజ్ చేయబడింది డేటా నిర్మాణం మద్దతు. ఎక్కువ సామర్థ్యంతో, వివిధ డిపెండెన్సీలను నెరవేర్చడానికి డేటా నిర్మాణాన్ని నియంత్రించగలగడం చాలా ముఖ్యం. లో జాబితా యొక్క ఉప-ఇంటర్ఫేస్ ఇది స్థాన ప్రాప్యత, పునరుక్తి మొదలైన అంశాలతో సరైన పరిష్కారాలను ఇస్తుంది. ఈ వ్యాసంలో, మేము జావాలోని జాబితా ఇంటర్‌ఫేస్‌లో వివిధ కార్యకలాపాలను చర్చిస్తాము. ఈ బ్లాగులో చర్చించిన విషయాలు క్రిందివి:
జావాలో జాబితా ఇంటర్ఫేస్
జావాలోని జాబితా ఇంటర్ఫేస్ జావా సేకరణల ఇంటర్ఫేస్ యొక్క ఉప-ఇంటర్ఫేస్. ఇది ఆదేశించబడింది మరియు చొప్పించడం మరియు తొలగించేటప్పుడు స్థానం యొక్క వశ్యతతో నకిలీ ఎంట్రీలను అనుమతిస్తుంది. మేము సూచికల సహాయంతో మూలకాలను యాక్సెస్ చేయవచ్చు, ఇది శోధన కార్యకలాపాలకు కూడా సహాయపడుతుంది.
ద్వారా జాబితా అమలు , వెక్టర్స్ మరియు స్టాక్ తరగతులు. జాబితాను అమలు చేయడానికి వాక్యనిర్మాణం క్రిందిది జావాలో ఇంటర్ఫేస్ .
పబ్లిక్ ఇంటర్ఫేస్ జాబితా సేకరణను విస్తరించింది
జావా జాబితా తరగతి రేఖాచిత్రం
జాబితా ఇంటర్ఫేస్ ఇటరేటర్ ఇంటర్ఫేస్ను విస్తరించే సేకరణ ఇంటర్ఫేస్ను విస్తరిస్తుంది. సారాంశ-జాబితా ప్రయత్నాన్ని తగ్గించడానికి జాబితా ఇంటర్ఫేస్ యొక్క ఆప్టిమైజ్ అమలును అందిస్తుంది. మేము జావాలో జాబితా ఇంటర్ఫేస్ను ఉపయోగించినప్పుడు మా వద్ద ఉన్న పద్ధతులు క్రిందివి.
వివరణతో ఇంటర్ఫేస్ పద్ధతులను జాబితా చేయండి
| విధానం | వివరణ |
| శూన్య జోడింపు (పూర్ణాంక సూచిక, E మూలకం) | ఇది ఒక నిర్దిష్ట స్థానంలో మూలకాలను చొప్పించడానికి ఉపయోగించబడుతుంది |
| బూలియన్ యాడ్ (E ఇ) | ఇది జాబితా చివరిలోని అంశాలను జోడిస్తుంది |
| బూలియన్ యాడ్అల్ (పూర్ణాంక సూచిక, సేకరణ సి) | ఇది జాబితా చివరిలో పేర్కొన్న సేకరణలోని అంశాలను జోడిస్తుంది |
| void clear () | జాబితా నుండి అన్ని అంశాలను తొలగిస్తుంది |
| బూలియన్ సమానం (ఆబ్జెక్ట్ ఓ) | ఇది పేర్కొన్న వస్తువును జాబితాలోని మూలకాలతో పోలుస్తుంది |
| int హాష్కోడ్ () | ఇది జాబితా యొక్క హాష్ కోడ్ విలువను అందిస్తుంది |
| E పొందండి (పూర్ణాంక సూచిక) | ఇది జాబితా యొక్క ఒక నిర్దిష్ట స్థానం నుండి అంశాలను పొందుతుంది |
| బూలియన్ isEmpty () | జాబితా ఖాళీగా ఉందో లేదో ఇది తనిఖీ చేస్తుంది |
| int lastIndexOf (ఆబ్జెక్ట్ o) | పేర్కొన్న వస్తువు యొక్క సూచిక విలువను చూపుతుంది |
| ఆబ్జెక్ట్ [] toArray () | ఇది జాబితాలోని అన్ని అంశాలతో ఒక శ్రేణిని సరైన క్రమంలో అందిస్తుంది |
| T [] toArray (T [] a) | జాబితాలోని అన్ని అంశాలతో శ్రేణిని అందిస్తుంది |
| బూలియన్ కలిగి ఉంది (ఆబ్జెక్ట్ ఓ) | పేర్కొన్న మూలకం జాబితాలో ఉంటే అది నిజం అవుతుంది |
| బూలియన్ అన్ని (కలెక్షన్) కలిగి ఉంటుంది | ఇది జాబితాలోని బహుళ అంశాలను తనిఖీ చేస్తుంది |
| పూర్ణాంక సూచికఆఫ్ (ఆబ్జెక్ట్ ఓ) | మొదటి సందర్భంలో మూలకం యొక్క సూచికను అందిస్తుంది |
| E తొలగించు (పూర్ణాంక సూచిక) | పేర్కొన్న ప్రదేశంలో మూలకాలను తొలగిస్తుంది |
| బూలియన్ తొలగించు (ఆబ్జెక్ట్ ఓ) | ఇది పేర్కొన్న మూలకం యొక్క మొదటి సంఘటనను తొలగిస్తుంది |
| బూలియన్ రిమూవల్అల్ (కలెక్షన్ సి) | జాబితా నుండి అన్ని అంశాలను తొలగిస్తుంది |
| void replaceAll (UnaryOperator operator) | పేర్కొన్న మూలకాలతో అన్ని అంశాలను భర్తీ చేస్తుంది |
| శూన్య నిలుపుదల అన్ని (సేకరణ సి) | పేర్కొన్న అంశంలో అన్ని అంశాలను కలిగి ఉంటుంది |
| E సెట్ (పూర్ణాంక సూచిక, E మూలకం) | పేర్కొన్న ప్రదేశంలో పేర్కొన్న మూలకాన్ని భర్తీ చేస్తుంది |
| శూన్యమైన క్రమబద్ధీకరణ (కంపారిటర్ సి) | పేర్కొన్న పోలిక ఆధారంగా జాబితాను క్రమబద్ధీకరిస్తుంది |
| స్ప్లిటరేటర్ స్ప్లిటేటర్ () | అంశాలపై స్ప్లిటేటర్‌ను సృష్టిస్తుంది |
| జాబితా సబ్లిస్ట్ (int fromIndex, int toIndex) | ఇచ్చిన పరిధిలో మూలకాలను పొందుతుంది |
| పూర్ణాంక పరిమాణం () | జాబితాలోని మూలకాల సంఖ్యను చూపుతుంది |
జావాలో జాబితాలో కార్యకలాపాలు
మేము వేర్వేరు పద్ధతులను ఉపయోగించి జాబితాలో వివిధ కార్యకలాపాలను చేయవచ్చు. ఈ కార్యకలాపాలలో స్థాన ప్రాప్యత, శోధన ఆపరేషన్, పునరావృతం మొదలైనవి ఉన్నాయి. జాబితాలో కార్యకలాపాలను చూపించడానికి ఈ క్రింది కొన్ని ఉదాహరణలు ఉన్నాయి .
జాబితా వస్తువులను సృష్టిస్తోంది
జాబితా వస్తువును సృష్టించడం సంప్రదాయ వస్తువులను సృష్టించడం లాంటిది. జాబితా చేయడానికి క్రింది ఉదాహరణ వస్తువులు జావాలో.
ఒక = క్రొత్త స్టాక్ () జాబితా b = క్రొత్త వెక్టర్ () జాబితా c = క్రొత్త శ్రేణి జాబితా () జాబితా d = క్రొత్త లింక్డ్లిస్ట్ () // జెనెరిక్స్ విడుదలైన తరువాత, మేము వస్తువు యొక్క రకాన్ని కూడా పరిమితం చేయవచ్చు. జాబితా జాబితా = క్రొత్త శ్రేణి జాబితా ()
స్థాన ప్రాప్యత
జావాలోని జాబితాలో స్థాన ప్రాప్యతను చూపించడానికి క్రింది ఉదాహరణ.
java.util ను దిగుమతి చేయండి. * పబ్లిక్ క్లాస్ డెమో {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {జాబితా జాబితా = క్రొత్త శ్రేణి జాబితా () list.add (0,1) list.add (1,3) list.add (2, 5) list.add (3,7) System.out.println (list) list.remove (3) System.out.println (list.get (2)) list.set (3,5) System.out.println (జాబితా)}}వెతకండి
సూచికలతో శోధించడం సులభం. జావాలోని జాబితాలో శోధన ఆపరేషన్ చూపించడానికి క్రింది ఉదాహరణ.
java.util ను దిగుమతి చేయండి. * పబ్లిక్ క్లాస్ డెమో {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {జాబితా జాబితా = క్రొత్త శ్రేణి జాబితా () list.add ('ఎడురేకా') list.add ('జావా ప్రోగ్రామింగ్') list.add (' J2EE ') System.out.println (indexOf (' Java Programming ')) System.out.println (lastIndexOf (' Edureka ')) System.out.println (indexOf (' Advance Java '))}}మరల
జావాలోని జాబితా క్రమం మీద మళ్ళించడానికి ListIterator ఉపయోగించబడుతుంది. ఇది ప్రకృతిలో ద్వైపాక్షికం. జావాలో ListIterator కోసం కొన్ని పద్ధతులు క్రిందివి.
ListIterator ఇంటర్ఫేస్
| విధానం | వివరణ |
| శూన్య జోడింపు (E ఇ) | జాబితాలో మూలకాన్ని చొప్పిస్తుంది |
| బూలియన్ hasNext () | ఫార్వర్డ్ ట్రావెర్సల్ తదుపరి మూలకాన్ని కలిగి ఉంటే నిజం అవుతుంది |
| ఇ తదుపరి () | జాబితాలోని తదుపరి మూలకాన్ని అందిస్తుంది |
| int nextindex () | జాబితాలోని తదుపరి సూచికను చూపుతుంది |
| బూలియన్ hasPrevious () | వెనుకబడిన ట్రావెర్సల్ తదుపరి మూలకాన్ని కలిగి ఉంటే నిజం అవుతుంది |
| E మునుపటి () | జాబితాలోని మునుపటి మూలకాన్ని అందిస్తుంది |
| E మునుపటిఇండెక్స్ () | జాబితాలోని మునుపటి సూచికను చూపుతుంది |
| void remove () | ఇది జాబితాలోని చివరి మూలకాన్ని తొలగిస్తుంది |
| శూన్య సెట్ (E మరియు) | ఇది చివరి మూలకాన్ని పేర్కొన్న విలువతో భర్తీ చేస్తుంది |
ప్రకటన
పనిముట్లు మరియు విస్తరణల మధ్య జావా వ్యత్యాసం
పబ్లిక్ ఇంటర్ఫేస్ ListIterator ఇటిరేటర్ను విస్తరించింది
ListIterator ఉదాహరణ
java.util ను దిగుమతి చేయండి. * పబ్లిక్ క్లాస్ డెమో {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {జాబితా జాబితా = క్రొత్త శ్రేణి జాబితా () list.add ('ఎడురేకా') list.add ('జావా') list.add ('J2EE ') list.add (' అడ్వాన్స్ జావా ') ListIterator li = list.listIterator () System.out.println (' ఫార్వర్డ్ మళ్ళా ') అయితే (li.hasNext ()) {System.out.println (' index = '+ li.nextIndex () + 'value =' + li.next ())} System.out.println ('backward iteration') అయితే (li.hasPrevious ()) {System.out.println ('index =' + li .previousIndex () + 'value =' + li.previous ())}}}పరిధి-వీక్షణ
జాబితా ఇంటర్ఫేస్ జాబితా యొక్క భాగాల జాబితా వీక్షణను పొందడానికి పద్ధతులను అందిస్తుంది. శ్రేణి వీక్షణ ఆపరేషన్‌ను చూపించడానికి క్రింది ఉదాహరణ.
java.util ను దిగుమతి చేయండి. list.add ('J2EE') list.add ('అడ్వాన్స్ జావా') జాబితా జాబితా 2 = క్రొత్త శ్రేణి జాబితా () list2 = list.subList (2,4) System.out.println (list2)}}ఈ వ్యాసంలో, జావాలోని జాబితా ఇంటర్‌ఫేస్‌లో కార్యకలాపాలను కలిగి ఉన్న వివిధ ఉదాహరణలను మేము చర్చించాము. ఆప్టిమైజేషన్ సామర్థ్యానికి దారితీస్తుంది మరియు జాబితా ఇంటర్‌ఫేస్‌కు మద్దతుగా అన్ని పద్ధతులతో, మంచి ఫలితాల కోసం ఏ డెవలపర్‌ అయినా జాబితాలతో పనిచేయడం సులభం అవుతుంది.
ఈ రోజుల్లో జావా ప్రోగ్రామింగ్ లాంగ్వేజ్ అత్యంత ఆశాజనక భాషలలో ఒకటిగా మారింది, పెరుగుతున్న డిమాండ్‌తో ఇది ఐటి పరిశ్రమలో చాలా ఉద్యోగ అవకాశాలను అందించింది. ఎడురేకాలో నమోదు చేసే అన్ని నైపుణ్యాలను నేర్చుకోవటానికి మరియు మీ వృత్తిని ప్రారంభించండి.
మాకు ప్రశ్న ఉందా? దయచేసి 'జావాలో జాబితా' లోని ఈ వ్యాసం యొక్క వ్యాఖ్యలలో దీనిని ప్రస్తావించండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.