జావాలో శ్రేణులపై ఆపరేషన్‌లను ఎలా సృష్టించాలి మరియు నిర్వహించాలి

అప్లికేషన్‌లను సృష్టించేటప్పుడు డేటాను నిల్వ చేయడానికి మరియు తిరిగి పొందడానికి డెవలపర్‌లకు శ్రేణులు సులభమైన మార్గాన్ని అందిస్తాయి.

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

ఏదేమైనా, శ్రేణిలో ఒకే మూలకాన్ని యాక్సెస్ చేయడం మాత్రమే లక్ష్యం అయితే, యాక్సెస్ మంజూరు చేయడానికి అవసరమైన మూలకం యొక్క సూచిక శ్రేణి పేరుతో కలిపి ఉండాలి.

శ్రేణిని ఎలా ఉపయోగించాలి

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

జావాలో శ్రేణిని ప్రకటించడం

జావాలో, శ్రేణులను రెండు మార్గాల్లో ఒకటిగా ప్రకటించవచ్చు; ప్రతి పద్ధతి మధ్య ఉన్న ప్రధాన వ్యత్యాసం ఏమిటంటే, ఒక దాని వేరియబుల్స్ నిర్వచించే సమయం వచ్చినప్పుడు మరొకటి కంటే ఎక్కువ స్థలాన్ని ఆక్రమిస్తుంది.

శ్రేణి ఉదాహరణను ప్రకటించడం

  
public class Arrays {  
public static void main(String[] args) {  
//declaring an integer array  
int[] arr1 = new int[10];  
}  
}

పై కోడ్‌తో, పేరుతో ఒక శ్రేణి ప్రకటించబడింది arr1. ఈ శ్రేణి 10 పూర్ణాంకాల జాబితాను నిల్వ చేయగలదు.

ఒకవేళ 10 పూర్ణాంకాలు నిల్వ చేయబడాలి arr1 పైన ఉపయోగం కోసం తక్షణమే అందుబాటులో ఉన్నాయి, ఈ ప్రక్రియకు అదనంగా 10 లైన్ల కోడ్ అవసరం.

శ్రేణి ఉదాహరణ జనాభాను

  
public class Arrays {  
public static void main(String[] args) {  
//declaring an integer array  
int[] arr1 = new int[10];  
//populate the array with 10 integer elements  
arr1[0] = 2;  
arr1[1] = 4;  
arr1[2] = 6;  
arr1[3] = 8;  
arr1[4] = 10;  
arr1[5] = 12;  
arr1[6] = 14;  
arr1[7] = 16;  
arr1[8] = 18;  
arr1[9] = 20;  
}  
}

శ్రేణులలో, 'సూచిక' అనే పదం జాబితాలో నిర్దిష్ట మూలకం యొక్క స్థానాన్ని సూచిస్తుంది. ప్రతి సూచిక స్థానం సంఖ్యా విలువ ద్వారా గుర్తించబడుతుంది మరియు డిఫాల్ట్‌గా ప్రతి శ్రేణి స్థానం సున్నా వద్ద మొదలవుతుంది.

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

విండోస్ స్టాప్ కోడ్ ఊహించని స్టోర్ మినహాయింపు

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

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

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

ఒక శ్రేణిని ప్రకటించడం మరియు జనాదరణ పొందడం

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

ఒక శ్రేణి ఉదాహరణకి వేరియబుల్స్ ప్రకటించడం మరియు కేటాయించడం

  
public class Arrays {  
public static void main(String[] args) {  
//declare and populate the array with 10 integer elements  
int[] arr2 = {1,3,5,7,9,11,13,15,17,19};  
}  
}

పై ఉదాహరణలో, arr2 10 బేసి పూర్ణాంక సంఖ్యల జాబితాతో సృష్టించబడింది మరియు జనాభా ఉంది. మునుపటి శ్రేణి వలె, arr2 ఇప్పుడు పూర్తయింది మరియు ఉపయోగం కోసం సిద్ధంగా ఉంది.

శ్రేణిలో వేరియబుల్స్‌ని యాక్సెస్ చేస్తోంది

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

ఈ విలువకు ప్రాప్యత పొందడానికి, మీరు రెండు విషయాలు తెలుసుకోవాలి; విలువ ఒక భాగం అయిన శ్రేణి పేరు మరియు ఆ శ్రేణిలోని విలువ యొక్క స్థానం. మా ఉదాహరణ నుండి, మీరు ఆ విలువను చూడవచ్చు పదకొండు అనే శ్రేణిలో ఉంది arr2 మరియు సూచిక 5 స్థానంలో.

కింది కోడ్ మీకు ఆ విలువకు ప్రాప్తిని అందిస్తుంది.

  
public class Arrays {  
public static void main(String[] args) {  
//declare and populate the array with 10 integer elements  
int[] arr2 = {1,3,5,7,9,11,13,15,17,19};  
//printing the value at position 5 to the console  
System.out.println(arr2[5]);  
}  
}

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

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

మీ శ్రేణులతో లూప్‌ల కోసం ఉపయోగించడం

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

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

ది లూప్ కోసం ఈ ఖచ్చితమైన పనిని స్పష్టంగా చేయటానికి పట్టే కోడ్‌లో సగం కంటే తక్కువగా ఉంటుంది.

వైఫైకి చెల్లుబాటు అయ్యే ఐపి కనెక్షన్ లేదు

లూప్ ఉదాహరణతో శ్రేణి మూలకాలను తిరిగి పొందడం

  
public class Arrays {  
public static void main(String[] args) {  
//declaring and initializing the array  
int[] arr2 = {1,3,5,7,9,11,13,15,17,19};  
//declaring the count variable  
int count;  
//using the for loop to print each element in the array to the console  
for(count = 0; count  System.out.println(arr2[count]);  
}  
}  
}

పై ఉదాహరణలో, పూర్ణాంక వేరియబుల్ పేరు పెట్టబడింది లెక్క సమయంలోని వివిధ పాయింట్ల వద్ద శ్రేణిలోని ప్రతి మూలకం యొక్క సూచిక స్థానాన్ని తీసుకుంటుంది. ఇది మొదటి లైన్‌లో సాధించబడింది లూప్ కోసం , ఎక్కడ లెక్క సున్నాకి ప్రారంభించబడింది, ఆపై శ్రేణి పొడవు కంటే తక్కువ విలువలకు పరిమితం చేయబడింది (కాబట్టి 10 కంటే తక్కువ).

తుది ఆపరేషన్ నడుస్తుంది లెక్క లూప్ అమలు చేసిన ప్రతిసారీ దాని విలువను శ్రేణి యొక్క సూచిక స్థానానికి పంపే ముందు దానిని పెంచడం విలువ. ఫర్ లూప్ యొక్క రెండవ లైన్ కింది ఫలితాన్ని కన్సోల్‌లో ఉత్పత్తి చేస్తుంది.

శ్రేణులు డేటాను నిల్వ చేయడం మరియు తిరిగి పొందడం సులభం చేస్తాయి

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

జావా భాష కూడా క్లాసులు అని పిలువబడే విభాగాలుగా చక్కగా రూపొందించబడింది, మరియు మీరు భాషను సమర్థవంతంగా ఉపయోగించాలనుకుంటే దానిలో తరగతులను ఎలా సృష్టించాలో మీరు తెలుసుకోవాలి.

షేర్ చేయండి షేర్ చేయండి ట్వీట్ ఇమెయిల్ జావాలో తరగతులను ఎలా సృష్టించాలో తెలుసుకోండి

మీరు జావాలో ప్రోగ్రామ్ చేయడం నేర్చుకుంటే, తరగతులను ఎలా సృష్టించాలో మీరు తెలుసుకోవాలి.

తదుపరి చదవండి సంబంధిత అంశాలు

ప్రోగ్రామింగ్
జావా
కోడింగ్ ట్యుటోరియల్స్

రచయిత గురుంచి కదీషా కీన్(21 కథనాలు ప్రచురించబడ్డాయి)

కదీషా కీన్ పూర్తి-స్టాక్ సాఫ్ట్‌వేర్ డెవలపర్ మరియు టెక్నికల్/టెక్నాలజీ రైటర్. ఆమె చాలా క్లిష్టమైన సాంకేతిక భావనలను సరళీకృతం చేసే ప్రత్యేక సామర్థ్యాన్ని కలిగి ఉంది; ఏదైనా టెక్నాలజీ అనుభవం లేని వ్యక్తి సులభంగా అర్థం చేసుకోగల పదార్థాన్ని ఉత్పత్తి చేయడం. ఆమె రాయడం, ఆసక్తికరమైన సాఫ్ట్‌వేర్‌ను అభివృద్ధి చేయడం మరియు ప్రపంచాన్ని పర్యటించడం (డాక్యుమెంటరీల ద్వారా) పట్ల మక్కువ చూపుతుంది.

కదీషా కీన్ నుండి మరిన్ని

మా వార్తాలేఖకు సభ్యత్వాన్ని పొందండి

టెక్ చిట్కాలు, సమీక్షలు, ఉచిత ఈబుక్‌లు మరియు ప్రత్యేకమైన డీల్స్ కోసం మా వార్తాలేఖలో చేరండి!

సభ్యత్వం పొందడానికి ఇక్కడ క్లిక్ చేయండి