జావాలో డైనమిక్ అర్రే అంటే ఏమిటి?

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

• జావాలో డైనమిక్ అర్రే పరిచయం
• పరిమాణం vs సామర్థ్యం
• రెట్టింపు అనుబంధాలు
• ఒక మూలకాన్ని తొలగిస్తోంది
• జావాలో డైనమిక్ అర్రే యొక్క పరిమాణాన్ని మార్చడం

జావాలో డైనమిక్ అర్రే పరిచయం

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

pl sql లో మినహాయింపు నిర్వహణ

• త్వరిత శోధన . శ్రేణుల మాదిరిగానే, ఇచ్చిన సూచిక వద్ద మూలకాన్ని తిరిగి పొందేటప్పుడు, O (1) సమయం పడుతుంది.

  
  
  

• వేరియబుల్ పరిమాణం . మనకు కావలసినన్ని అంశాలను చొప్పించగలము మరియు వాటిని ఉంచడానికి డైనమిక్ శ్రేణి తదనుగుణంగా విస్తరిస్తుంది.

• కాష్ ఫ్రెండ్లీ . శ్రేణుల మాదిరిగానే, డైనమిక్ శ్రేణులు ఒకదానికొకటి జ్ఞాపకశక్తిని ఉంచగలవు, తద్వారా కాష్లను సమర్థవంతంగా ఉపయోగించుకోవచ్చు.

మా కోడ్‌లో డైనమిక్ శ్రేణులను ఉపయోగించడంలో కొన్ని నష్టాలు ఉన్నాయి. అయినప్పటికీ, చాలా అనువర్తనాల్లో మనం చేసేదానికంటే ఎక్కువగా డైనమిక్ శ్రేణులను ఉపయోగిస్తాము, కొన్ని సందర్భాల్లో దాని పరిమితుల కారణంగా అవి ఎక్కువ ఇష్టపడే ఎంపికగా మారవు.

• నెమ్మదిగా చెత్త కేసు జతచేస్తుంది . సాధారణంగా, డైనమిక్ శ్రేణి చివరిలో క్రొత్త మూలకాన్ని చేర్చినప్పుడు, ఇది ఒక సందర్భంలో O (1) పడుతుంది. ఏదేమైనా, డైనమిక్ శ్రేణికి క్రొత్త వస్తువు కోసం ఎక్కువ సూచికలు లేకపోతే, అది విస్తరించాల్సిన అవసరం ఉంది, ఇది ఒక సమయంలో O (n) పడుతుంది.

  సి లో లింక్డ్ లిస్ట్ ప్రోగ్రామ్

• ఖరీదైన ఇన్సర్ట్‌లు మరియు తొలగింపులు. శ్రేణుల మాదిరిగానే, మూలకాలు ఒకదానికొకటి ప్రక్కనే నిల్వ చేయబడతాయి. కాబట్టి శ్రేణి మధ్యలో ఒక అంశాన్ని జోడించేటప్పుడు లేదా తీసివేసేటప్పుడు దీనికి ఇతర మూలకాలను నెట్టడం అవసరం, ఇది ఒక సమయంలో O (n) ను తీసుకుంటుంది.

దిగువ రేఖాచిత్రాలు శ్రేణులు నిజ సమయంలో ఎలా పనిచేస్తాయో చూపుతాయి మరియు మూలకాలు ఎలా పేర్చబడి ఉన్నాయో వర్ణిస్తాయి. సగటు కేసు మరియు సూచన ఫంక్షన్ల యొక్క చెత్త కేసు కోసం సూచనలు ఎలా మారుతాయో కూడా ఇది చూపిస్తుంది.

పరిమాణం వర్సెస్ సామర్థ్యం

మేము డైనమిక్ శ్రేణిని ప్రారంభించినప్పుడు, డైనమిక్ శ్రేణి అమలు అర్థం చేసుకున్న స్థిర-పరిమాణ శ్రేణిని సృష్టిస్తుంది. ప్రారంభ పరిమాణం అమలుకు అనుగుణంగా ఉంటుంది. ఉదాహరణకు, 10 సూచికలను ఉపయోగించడానికి మా అమలు శ్రేణిని చేద్దాం. ఇప్పుడు మేము మా డైనమిక్ శ్రేణికి నాలుగు అంశాలను చేర్చుతాము. ఇప్పుడు, మా డైనమిక్ శ్రేణి యొక్క పొడవు నాలుగు. అయినప్పటికీ, మా అంతర్లీన శ్రేణి యొక్క పొడవు 10 ఉంది. అందువల్ల, డైనమిక్ అర్రే పరిమాణం నాలుగు మరియు దాని సామర్థ్యం 10 అని మేము చెప్పగలం. డైనమిక్ అర్రే డైనమిక్ అర్రే యొక్క ముగింపు బిందువు మరియు ప్రారంభాన్ని ట్రాక్ చేయడానికి ఒక నిర్దిష్ట ముగింపు సూచికను నిల్వ చేస్తుంది. అదనపు సామర్థ్యం ప్రారంభమయ్యే చోటు.

రెట్టింపు అనుబంధాలు

సామర్థ్యం ఇప్పటికే నిండిన శ్రేణికి ఒక అంశాన్ని జోడించడానికి మేము ప్రయత్నించిన సందర్భాలు ఉండవచ్చు. అందువల్ల, గది డైనమిక్ శ్రేణులను సృష్టించడానికి స్వయంచాలకంగా కొత్త, పెద్ద మరియు అంతర్లీన శ్రేణిని సృష్టించండి. సాధారణంగా, ఏదైనా కొత్త చేర్పులను నిర్వహించడానికి ఇది రెండు రెట్లు పెద్దదిగా మారుతుంది, ఇది ఇంతకు ముందు not హించలేదు. అందువల్ల, ప్రతి వస్తువును కాపీ చేయడానికి సమయం ఉండదు. మా డైనమిక్ శ్రేణికి అంశాన్ని జోడించినప్పుడల్లా స్వయంచాలకంగా క్రొత్త డబుల్-సైజ్ అంతర్లీన శ్రేణిని చేస్తుంది, ఇది అనుబంధానికి సమయం పట్టదు.

ఒక మూలకాన్ని తొలగిస్తోంది

శ్రేణి నుండి ఒక మూలకాన్ని తొలగించేటప్పుడు, డిఫాల్ట్ “తొలగించు ()” పద్ధతి చివరి నుండి ఒక మూలకాన్ని తొలగిస్తుంది మరియు చివరి సూచిక వద్ద స్వయంచాలకంగా సున్నాను నిల్వ చేస్తుంది. ఇది “నేను” సూచిక అయిన removeAt (i) పద్ధతిని పిలవడం ద్వారా నిర్దిష్ట సూచికలోని అంశాలను కూడా తొలగిస్తుంది. RemoveAt (i) పద్ధతి ఇచ్చిన సూచిక నుండి ఎడమ వైపున ఉన్న అన్ని కుడి మూలకాలను మారుస్తుంది.

శ్రేణిని మార్చడం

శ్రేణికి కుడి వైపున డేటా లేనప్పుడు అనవసరమైన మెమరీని తీసుకునేటప్పుడు, srinkSize () పద్ధతి అదనపు మెమరీని విముక్తి చేస్తుంది. అన్ని స్లాట్లు వినియోగించబడినప్పుడు మరియు అదనపు అంశాలు జోడించబడినప్పుడు, అంతర్లీన స్థిర-పరిమాణ శ్రేణి పరిమాణాన్ని పెంచాలి. అసలు పున izing పరిమాణం ఖరీదైనది, ఎందుకంటే మేము ఒక పెద్ద శ్రేణిని కేటాయించి, క్రొత్త అంశాన్ని చివరకు చేర్చడానికి ముందే మీరు పెరిగిన శ్రేణి నుండి అన్ని అంశాలను ముందుకు కాపీ చేయాలి.

శ్రేణి పరిమాణం పూర్తి అయ్యే మరియు క్రొత్త అంశాలు క్రొత్త డబుల్ సైజు శ్రేణికి కాపీ చేయబడిన ప్రోగ్రామ్ యొక్క ఉదాహరణ క్రింద ఉంది. “మహావీర్” అని పిలువబడే స్ట్రింగ్ ఎలిమెంట్ అయిన మూలకం ఇప్పటికే పూర్తి పరిమాణం 3 కి అదనంగా ఉంటుంది.

c ఆధారంగా జావా

దిగుమతి java.util.ArrayList దిగుమతి java.util. శ్రేణి యొక్క పరిమాణాన్ని నమోదు చేయండి :: ') int size = sc.nextInt () స్ట్రింగ్ myArray [] = కొత్త స్ట్రింగ్ [పరిమాణం] System.out.println (' శ్రేణి యొక్క మూలకాలను నమోదు చేయండి (స్ట్రింగ్స్) :: ') (int i = 0 i
 అవుట్పుట్: 
దీనితో, మేము జావా వ్యాసంలో డైనమిక్ అర్రే చివరికి వస్తాము. డైనమిక్ శ్రేణులతో ఎలా పని చేయాలో మీకు ఒక ఆలోచన వచ్చిందని నేను ఆశిస్తున్నాను.
 చూడండి     ప్రపంచవ్యాప్తంగా విస్తరించి ఉన్న 250,000 మందికి పైగా సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించబడింది. ఈ కోర్సు మీకు జావా ప్రోగ్రామింగ్‌లోకి రావడానికి మరియు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌లతో పాటు కోర్ మరియు అడ్వాన్స్‌డ్ జావా కాన్సెప్ట్‌లకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది. 
 మాకు ప్రశ్న ఉందా? దయచేసి ఈ “జావాలోని డైనమిక్ అర్రే” బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.