శ్రేణులు

1. శ్రేణి అనేది మూలకాల యొక్క కంటైనర్

కంప్యూటర్లు భారీ మొత్తంలో సమాచారాన్ని ప్రాసెస్ చేయగలవని మీరు బహుశా విన్నారు. వాస్తవానికి, షరతులతో కూడిన ప్రకటనలు ( if-else) మరియు లూప్‌లు ( for, while) ఇక్కడ పెద్ద సహాయం. కానీ వారు మిమ్మల్ని ఇంత దూరం మాత్రమే తీసుకెళ్లగలరు. అన్నింటికంటే, మీరు ప్రాసెస్ చేసే డేటా ఏదో ఒకవిధంగా నిల్వ చేయబడాలి.

దాదాపు అన్ని ప్రోగ్రామింగ్ లాంగ్వేజ్‌ల మాదిరిగానే, జావా శ్రేణి ( Arrayక్లాస్) అని పిలువబడే ఈ గొప్ప విషయాన్ని అందించడం ద్వారా డేటా ప్రాసెసింగ్‌ను సులభతరం చేస్తుంది. వాటిని కొన్నిసార్లు పట్టికలు అని కూడా పిలుస్తారు.

శ్రేణి అనేది ఒక ప్రత్యేక వస్తువు, ఇది ఒక విలువను కాకుండా అనేక వాటిని నిల్వ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది .

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

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

అర్రే వేరియబుల్ అనేది హై-రైజ్ వేరియబుల్ లాంటిది. ఇది ఒకటి కాదు అనేక విలువలను నిల్వ చేయగలదు. ఇటువంటి వేరియబుల్ అనేక అపార్ట్మెంట్లను (కణాలు) కలిగి ఉంటుంది. వాటిలో ప్రతి ఒక్కటి వారి సంఖ్య (సూచిక) ద్వారా పరిష్కరించబడుతుంది.

దీన్ని చేయడానికి, వేరియబుల్ పేరు తర్వాత, మీరు సూచించాలనుకుంటున్న సెల్ యొక్క సూచికను సూచిస్తారు, సూచికను చదరపు బ్రాకెట్లలో చుట్టండి. ఇది చాలా సులభం:

array[index] = value;

arrayశ్రేణి వేరియబుల్ పేరు ఎక్కడ ఉంది, indexశ్రేణిలోని సెల్ నంబర్ మరియు valueమేము పేర్కొన్న సెల్‌లో ఉంచాలనుకుంటున్న విలువ.

కానీ ప్రారంభించడానికి, శ్రేణులను ఎలా సృష్టించాలో చూద్దాం.

2. జావాలో మూలకాల శ్రేణిని సృష్టించడం

100మీ ప్రోగ్రామ్ పూర్ణాంకాలను ఎక్కడో నిల్వ చేయాలని అనుకుందాం . శ్రేణి దీనికి మంచి అభ్యర్థిగా ఉంటుంది. మరియు మీరు ఒకదాన్ని ఎలా సృష్టిస్తారు?

మనం ఒకే పూర్ణాంకాన్ని నిల్వ చేయాలనుకుంటే, ఆ intరకం మనకు సరిపోతుంది. కానీ మేము పూర్ణాంకాలను నిల్వ చేయాలనుకుంటే 100, మనకు బహుశా s యొక్క శ్రేణిint అవసరం . ఒకదాన్ని సృష్టించే కోడ్ ఇలా కనిపిస్తుంది:

int[] array = new int[100];

ఈ ప్రకటనను పరిశీలిద్దాం.

మీరు ఊహించినట్లుగా, సమాన గుర్తుకు ఎడమవైపున మేము ఒక వేరియబుల్ యొక్క డిక్లరేషన్‌ని కలిగి ఉన్నాము, arrayదీని రకం int[]. రకాన్ని intచతురస్రాకార బ్రాకెట్‌లు అనుసరిస్తాయి, ఈ రకమైన "బాక్స్‌లు" ఒకటి కాకుండా అనేక విలువలను నిల్వ చేయగలవని ఇది సూచిస్తుంది.

సమాన గుర్తుకు కుడి వైపున, పూర్ణాంక రకాన్ని కలిగి ఉన్న మూలకాలను (సెల్‌లు) newపొందడానికి మనకు "వస్తు సృష్టి" (కీవర్డ్) ఉదాహరణ ఉంది . 100ఇక్కడ చాలా కష్టం ఏమీ లేదు.

అదేవిధంగా, మేము వాస్తవ సంఖ్యలను నిల్వ చేయడానికి 20 కణాల శ్రేణిని సృష్టించాలనుకుంటే , మా కోడ్ ఇలా కనిపిస్తుంది:

double[] vals = new double[20];

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

ఇక్కడ ఒక ముఖ్యమైన వాస్తవం ఉంది: మీరు శ్రేణిని సృష్టించిన తర్వాత దాని పరిమాణాన్ని మార్చలేరు .

మీరు కొత్తదాన్ని సృష్టించవచ్చు, కానీ ఇప్పటికే ఉన్న కంటైనర్ పొడవు మార్చబడదు.

3. శ్రేణి యొక్క కణాలతో పని చేయడం

సరే, మేము శ్రేణులను ఎలా సృష్టించాలో నేర్చుకున్నాము. ఇప్పుడు మనం వారితో ఎలా పని చేయాలి?

సరే, దాదాపు సాధారణ వేరియబుల్స్ మాదిరిగానే. ఒకే తేడా ఏమిటంటే, అర్రే వేరియబుల్ పేరు తర్వాత, మనం పని చేస్తున్న సెల్ సంఖ్యను సూచించాలి.

శ్రేణిలోని కణాల సంఖ్య ఎల్లప్పుడూ సున్నా నుండి ప్రారంభమవుతుంది. మనకు మూలకాల శ్రేణి ఉంటే 10, దాని కణాల సంఖ్యలు (సూచికలు) 0..9. శ్రేణి 200మూలకాలను కలిగి ఉంటే, అప్పుడు సూచికలు 0..199. మరియు సారూప్యత ద్వారా.

ఉదాహరణలు:

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

ఈ కోడ్ అమలు చేయబడిన తర్వాత ఇది మెమరీలో నిల్వ చేయబడుతుంది:

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

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