జావాలో ప్రోగ్రామింగ్ చేస్తున్నప్పుడు, శ్రేణిలో బల్క్ డేటాను కూడబెట్టుకోవాల్సిన అవసరం ఉంటుంది. ఉదాహరణకు, డేటాను చదవగలిగేలా మరియు ప్రభావవంతమైన పద్ధతిలో యాక్సెస్ చేసేలా అమర్చడం మరియు క్రమబద్ధీకరించడం. అటువంటి సందర్భాలలో, శ్రేణిని ప్రారంభించడం మరియు ఉపయోగించడం అనేది కలిగి ఉన్న వనరులను సమర్ధవంతంగా నిర్వహించడంలో సహాయకరంగా ఉంటుంది.
ఈ బ్లాగ్ జావాను ఉపయోగించి శ్రేణిని ప్రారంభించే విధానాలను వివరిస్తుంది.
జావాలో అర్రేని ఎలా ప్రారంభించాలి?
శ్రేణిని అనేక విధాలుగా ప్రారంభించవచ్చు. ఇవి కేటాయించని విలువలతో దీన్ని ప్రారంభించడం, ప్రకటించిన తర్వాత ప్రారంభించడం లేదా పూర్ణాంకం మరియు స్ట్రింగ్ విలువలు రెండింటితో ఒకేసారి ప్రారంభించడం.
వాక్యనిర్మాణం
సమాచార తరహా [ ] శ్రేణి పేరు
పై వాక్యనిర్మాణంలో:
-
- ' సమాచార తరహా ” అనేది పూర్ణాంకం, స్ట్రింగ్ మొదలైన శ్రేణి డేటా రకానికి అనుగుణంగా ఉంటుంది.
- ' [ ] ” చదరపు బ్రాకెట్‌లు శ్రేణి పరిమాణాన్ని సూచిస్తాయి.
శ్రేణిని ప్రారంభించేందుకు చర్చించబడిన అవకాశాలు ఇప్పుడు ఒక్కొక్కటిగా వివరించబడతాయి!
ఉదాహరణ 1: జావాలో విలువలను కేటాయించకుండా అర్రేని ప్రారంభించండి
ఈ ఉదాహరణలో, విలువలను కేటాయించకుండా శ్రేణిని ప్రారంభించవచ్చు:
int [ ] నమూనాఅర్రే = కొత్త పూర్ణాంకము [ 3 ] ;కోసం ( int i = 0 ; i < 3 ; i++ ) {
System.out.println ( 'నియమించని విలువలతో కూడిన శ్రేణి:' + నమూనా అర్రే [ i ] ) ;
}
పై కోడ్‌కు అనుగుణంగా క్రింది దశలను వర్తించండి:
-
- ముందుగా, '' అనే అర్రేని ప్రారంభించండి నమూనాఅరే ” మరియు దాని పరిమాణాన్ని నిర్వచించండి. అంటే, ' 3 ”.
- ఆ తరువాత, వర్తించు ' కోసం ” లూప్ శ్రేణితో పాటు మళ్ళించబడుతుంది మరియు దానిని కన్సోల్‌లో ముద్రించండి.
అవుట్‌పుట్
శ్రేణిలో మూలకాలు ఏవీ లేనందున, పునరావృతం విలువను అందిస్తుంది “ 0 ” ప్రతి శ్రేణి సూచికల వద్ద.
ఉదాహరణ 2: జావాలో డిక్లరేషన్ తర్వాత అర్రేని ప్రారంభించండి
ఈ ప్రత్యేక ఉదాహరణలో, పూర్ణాంక విలువలతో ఒక శ్రేణి ప్రకటించబడుతుంది మరియు ప్రారంభించబడుతుంది మరియు సేకరించబడిన శ్రేణి విలువలు వరుసగా కన్సోల్‌లో ప్రదర్శించబడతాయి:
int [ ] ఎంట్రీలు;entries = కొత్త int [ ] { 1 , 2 , 3 } ;
కోసం ( int i = 0 ; i < 3 ; i++ ) {
System.out.println ( 'ప్రారంభం తర్వాత శ్రేణి అవుతుంది:' +ప్రవేశాలు [ i ] ) ;
}
పై కోడ్ లైన్లలో:
-
- అన్నింటిలో మొదటిది, '' అనే అర్రేని ప్రకటించండి ఎంట్రీలు ”.
- తదుపరి దశలో, పేర్కొన్న పూర్ణాంక విలువలను దానికి కేటాయించండి.
- చివరగా, వర్తించు ' కోసం ” లూప్ శ్రేణి ఎంట్రీల వెంట తిరిగి మరియు వాటిని ప్రదర్శించడానికి.
అవుట్‌పుట్
ఎగువ అవుట్‌పుట్‌లో, శ్రేణిలో కేటాయించిన విలువలు పునరావృతం చేసిన తర్వాత ప్రదర్శించబడినట్లు చూడవచ్చు.
ఉదాహరణ 3: జావాలో ఏకకాలంలో అర్రేలో విలువలను ప్రారంభించండి మరియు కేటాయించండి
ఈ ప్రత్యేక ఉదాహరణలో, శ్రేణిని ప్రారంభించడం మరియు దానిలోని విలువల కేటాయింపు ఏకకాలంలో నిర్వహించబడుతుంది:
int [ ] ఎంట్రీలు = { 1 , 2 , 3 } ;కోసం ( int i = 0 ; i < 3 ; i++ ) {
System.out.println ( 'ప్రారంభించబడిన శ్రేణి అవుతుంది:' +ప్రవేశాలు [ i ] ) ;
}
పై కోడ్ స్నిప్పెట్‌లో ఇచ్చిన విధంగా క్రింది దశలను అమలు చేయండి:
-
- పేరు గల శ్రేణిని ప్రారంభించండి ఎంట్రీలు ” మరియు అదే సమయంలో పేర్కొన్న విలువలను కేటాయించండి.
- తదుపరి దశలో, అదే విధంగా, ' కోసం ” లూప్ శ్రేణి విలువల ద్వారా పునరావృతం చేయడానికి మరియు వాటిని ప్రదర్శించడానికి.
అవుట్‌పుట్
అర్రే డిక్లరేషన్ మరియు ఇనిషియలైజేషన్ సముచితంగా జరిగాయని పై అవుట్‌పుట్ సూచిస్తుంది.
ఉదాహరణ 4: జావాలో పూర్ణాంకం మరియు స్ట్రింగ్ విలువలు రెండింటితో అర్రేని ప్రారంభించండి
ఈ ప్రదర్శనలో, పూర్ణాంకం మరియు స్ట్రింగ్ విలువలు రెండింటితో శ్రేణి ప్రారంభించబడుతుంది:
వస్తువు [ ] ఎంట్రీలు = { 'హ్యారీ' , 1 , 2 , 'డేవిడ్' , 3 } ;కోసం ( int i = 0 ; i < 5 ; i++ ) {
System.out.println ( 'ప్రారంభించబడిన శ్రేణి అవుతుంది:' +ప్రవేశాలు [ i ] ) ;
}
పై కోడ్ లైన్లలో:
-
- ముందుగా, '' అనే అర్రేని ప్రారంభించండి ఎంట్రీలు ”పూర్ణాంకం మరియు స్ట్రింగ్ విలువలు రెండింటితో.
- గమనించండి' వస్తువు ” పూర్ణాంకం మరియు స్ట్రింగ్ విలువలు రెండింటినీ శ్రేణిలో సేకరించవచ్చని సూచిస్తుంది.
- చివరగా, అదేవిధంగా, వర్తించు ' కోసం ” లూప్ శ్రేణి విలువలతో పాటు పునరావృతం చేసి వాటిని ప్రదర్శించండి.
అవుట్‌పుట్
ఇది జావాలో శ్రేణులను ప్రారంభించడం గురించి.
ముగింపు
జావాలోని శ్రేణిని డిక్లరేషన్ తర్వాత లేదా పూర్ణాంకం మరియు స్ట్రింగ్ విలువలు రెండింటితో విలువలను కేటాయించకుండా ప్రారంభించవచ్చు. ఇది సహాయంతో చేయబడుతుంది ' చదరపు బ్రాకెట్లలో [ ] ” ఆపై దానికి (శ్రేణి) విలువలను కేటాయించడం. ఈ విలువలు పూర్ణాంకాలు, స్ట్రింగ్‌లు లేదా రెండూ కావచ్చు. ఈ బ్లాగ్ జావాలో శ్రేణిని ప్రారంభించే విధానాలను చర్చించింది.