శ్రేణులతో పని చేసే సూక్ష్మ నైపుణ్యాలు

1. మెమరీలో శ్రేణులు

మునుపటి ఉదాహరణలలో, దృష్టాంతాలు కొద్దిగా సరికానివి.

శ్రేణులను సృష్టించేటప్పుడు (స్ట్రింగ్‌లను సృష్టించేటప్పుడు), రెండు వేర్వేరు మెమరీ బ్లాక్‌లు కేటాయించబడతాయి: ఒకటి శ్రేణిని నిల్వ చేయడానికి ( కంటైనర్) మరియు దాని చిరునామాను నిల్వ చేసే వేరియబుల్ కోసం రెండవ బ్లాక్ . దిగువ చిత్రం ఈ స్పష్టీకరణను సూచిస్తుంది:

మూలకాల యొక్క శ్రేణి కోసం కేటాయించిన మెమరీ 10 intమరియు శ్రేణి చిరునామానుint[] నిల్వ చేసే వేరియబుల్ ఆకుపచ్చ రంగులో చూపబడింది.int

intపోలిక కోసం, విలువను నిల్వ చేసే సాధారణ వేరియబుల్ 199నీలం రంగులో చూపబడింది.

ఇది మెమరీలో తీగలను నిల్వ చేయడాన్ని కొద్దిగా గుర్తు చేస్తుంది, మీరు అనుకోలేదా?

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

int[] a = new int[10];
a[2] = 4;
a[7] = 9;
int[] b = a;

a[9] = b[2] + a[7];

శ్రేణి ఆబ్జెక్ట్ అది ఉన్న చోటనే ఉంటుంది మరియు aమరియు bవేరియబుల్స్ ఒకే ఆబ్జెక్ట్‌కు ఒకే చిరునామాను (రిఫరెన్స్) నిల్వ చేస్తాయి. ఆ చిత్రాన్ని చూడు:

2. శ్రేణులతో పని చేయడం గురించి మరిన్ని వివరాలు

మీరు ఖచ్చితంగా ఏ రకమైన అంశాల శ్రేణిని సృష్టించవచ్చు. దీన్ని చేయడానికి, టైప్ పేరు తర్వాత చదరపు బ్రాకెట్లను వ్రాయండి. సాధారణంగా, శ్రేణిని సృష్టించడం ఇలా కనిపిస్తుంది:

type[] name = new type[number];

రకం అంటే మనం శ్రేణిలో నిల్వ చేసే మూలకాల రకం. పేరు అనేది శ్రేణిని సూచించడానికి మనం ఉపయోగించే వేరియబుల్ పేరు మరియు సంఖ్య అనేది శ్రేణిలోని కణాల సంఖ్య.

ఎగువ ఉదాహరణ శ్రేణి వేరియబుల్ మరియు అర్రే ఆబ్జెక్ట్‌ను సృష్టించడానికి కానానికల్ రూపం. వాస్తవానికి, ఇవి రెండు వేర్వేరు సంస్థలు.

మీరు అర్రే ఆబ్జెక్ట్ నుండి విడిగా అర్రే వేరియబుల్‌ని సృష్టించవచ్చు:

type[] name;
name = new type[number];

మరియు ముఖ్యమైనది కాని మరో విషయం:

ఉదాహరణలు:

int n = 100;
int[] a = new int[n];

int n = 100;
int[] a = new int[n * 2 + 3];

int n = 100;
int[] a = new int[n];
a[n-1] = 2;
a[n-2] = 3;
a[n/5] = a[n-1] + a[n-2]

// a[99] = 2;
// a[98] = 3;
// a[20] = a[99] + a[98];

3. అర్రే పొడవు

మీరు మునుపటి ఉదాహరణలో చూసినట్లుగా, మీరు ఒక శ్రేణి వేరియబుల్‌ను స్వయంగా సృష్టించవచ్చు మరియు తర్వాత కోడ్‌లో ఎక్కడో దానికి విలువను (శ్రేణి వస్తువుకు సూచన) కేటాయించవచ్చు. మీరు దీన్ని కూడా చేయవచ్చు:

int[] array;
if (a < 10)
   array = new int[10];
else
   array = new int[20];

మరియు ఇప్పుడు మీరు అటువంటి శ్రేణితో ఇంకా ఏమి చేయవచ్చు? అందులో ఎన్ని అంశాలు ఉన్నాయో ఎలా తెలుసుకోవాలి?

దీనికి సహాయం చేయడానికి, శ్రేణులు అనే పేరుతో ఒక ప్రత్యేక లక్షణాన్ని (వేరియబుల్) కలిగి ఉంటాయి length. మీరు ఈ వ్యక్తీకరణను ఉపయోగించి శ్రేణి పొడవును కనుగొనవచ్చు:

array.length;

ఇక్కడ arrayశ్రేణి వేరియబుల్ పేరు మరియు lengthఇది అర్రే యొక్క ఆస్తి పేరు. ఆస్తి విలువ lengthమార్చబడదు: lengthఆస్తిని ఇతర వేరియబుల్స్‌కు కేటాయించవచ్చు, కానీ దానికి ఏమీ కేటాయించబడదు (మీరు దీన్ని చేయడానికి ప్రయత్నిస్తే, ప్రోగ్రామ్ కేవలం కంపైల్ చేయదు).

మేము మునుపటి ఉదాహరణతో ఇలా కొనసాగించవచ్చు:

int[] array;
if (a < 10)
   array = new int[10];
else
   array = new int[20];
for (int i = 0; i < array.length; i++)
{
   System.out.println(array[i]);
}

4. జావాలోని శ్రేణుల గురించి వాస్తవాల సారాంశం

శ్రేణుల గురించి మనకు తెలిసిన వాటిని పునశ్చరణ చేద్దాం:

వాస్తవం 1. ఒక శ్రేణి అనేక కణాలను కలిగి ఉంటుంది.

వాస్తవం 2. మీరు నిర్దిష్ట సెల్‌ను దాని సంఖ్య (సూచిక) ఉపయోగించి యాక్సెస్ చేస్తారు.

వాస్తవం 3. అన్ని కణాలు ఒకే రకమైనవి.

వాస్తవం 4. అన్ని కణాల ప్రారంభ విలువ 0 (కణాలు సంఖ్యలను నిల్వ చేస్తే), null(కణాలు వస్తువు సూచనలను నిల్వ చేస్తే) లేదా false(కణాలు booleanవిలువలను నిల్వ చేస్తే). మీరు ఈ అధ్యాయంలో డిఫాల్ట్ విలువల గురించి మరింత తెలుసుకుంటారు .

వాస్తవం 5. String[] list ఒక వేరియబుల్ యొక్క ప్రకటన మాత్రమే. ఇది కంటైనర్ (అరే ఆబ్జెక్ట్) ను సృష్టించదు. వేరియబుల్‌ను ఉపయోగించడానికి, మీరు మొదట శ్రేణిని (కంటైనర్) సృష్టించాలి మరియు దానిని వేరియబుల్‌కు కేటాయించాలి. దిగువ ఉదాహరణ చూడండి.

వాస్తవం 6. మనం ఒక అర్రే ఆబ్జెక్ట్‌ను (కంటైనర్) సృష్టించినప్పుడు, అది ఎంత పెద్దదో, అంటే అందులో ఎన్ని సెల్‌లు ఉందో మనం తప్పనిసరిగా సూచించాలి. ఇది వంటి ప్రకటనతో చేయబడుతుంది: new TypeName[n];

వాస్తవం 7. శ్రేణి యొక్క పొడవును ప్రాపర్టీని ఉపయోగించి కనుగొనవచ్చు .length.

వాస్తవం 8. శ్రేణిని సృష్టించిన తర్వాత, మీరు దాని మూలకాల రకాన్ని లేదా అది నిల్వ చేసే మూలకాల సంఖ్యను మార్చలేరు.

String s;
String[] list;

list = new String[10];
int n = list.length;

list = new String[0];

list = null;
System.out.println(list[1]);

list = new String[10];
System.out.println(list[10]);