బహుళ సంఖ్యా విలువలు లేదా స్ట్రింగ్ విలువలను నిల్వ చేయడానికి ఏదైనా ప్రోగ్రామింగ్ భాషలో శ్రేణి ఉపయోగించబడుతుంది. కొన్నిసార్లు, దీనికి సంఖ్యా శ్రేణి విలువల మొత్తాన్ని లెక్కించడం అవసరం. శ్రేణి వేరియబుల్స్ అన్ని విలువలను పేర్కొనడం ద్వారా లేదా ప్రతి ఇండెక్స్ విలువను విడిగా నిర్వచించడం ద్వారా జావాలో ప్రకటించవచ్చు. జావా గట్టిగా టైప్ చేయబడిన భాష కాబట్టి, మీరు అర్రే డిక్లరేషన్ సమయంలో అర్రే విలువల డేటా రకాన్ని నిర్వచించాలి. 'ఫర్' లూప్, కస్టమ్ ఫంక్షన్ మరియు అంతర్నిర్మిత ఫంక్షన్‌ని ఉపయోగించి శ్రేణి విలువల మొత్తాన్ని లెక్కించే పద్ధతులు ఈ ట్యుటోరియల్‌లో చూపబడ్డాయి.
ఉదాహరణ 1: 'కోసం' లూప్ ఉపయోగించడం
కింది కోడ్‌తో జావా ఫైల్‌ను సృష్టించండి, అది “ఫర్” లూప్‌ని ఉపయోగించి అన్ని శ్రేణి విలువల మొత్తాన్ని గణిస్తుంది. కోడ్‌లో 6 సంఖ్యల శ్రేణి నిర్వచించబడింది. మొత్తం విలువను నిల్వ చేయడానికి వేరియబుల్ ప్రారంభించబడింది. తరువాత, శ్రేణి యొక్క పొడవు పొడవు లక్షణం ద్వారా లెక్కించబడుతుంది మరియు శ్రేణి యొక్క ప్రతి విలువను యాక్సెస్ చేయడం ద్వారా శ్రేణి విలువల మొత్తాన్ని లెక్కించడానికి 'ఫర్' లూప్ ఉపయోగించబడుతుంది.
పబ్లిక్ క్లాస్ SumofArray1 {
పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
// సంఖ్యా విలువల శ్రేణిని ప్రకటించండి
int [ ] numArr= { 8 , 10 , 55 , 6 , 29 , 12 } ;
// ఫలితాన్ని నిల్వ చేయడానికి వేరియబుల్‌ని ప్రారంభించండి
int output = 0 ;
// మొత్తం శ్రేణి మూలకాల సంఖ్యను లెక్కించండి
int పరిమాణం = numArr.length;
System.out.println ( 'శ్రేణి విలువలు:' ) ;
// లెక్కించు మొత్తం శ్రేణి విలువలు మరియు శ్రేణి విలువలను ముద్రించండి
కోసం ( int n = 0 ; n < పరిమాణం ; n++ ) {
System.out.println ( numArr [ n ] ) ;
output = అవుట్‌పుట్ + numArr [ n ] ;
}
// ముద్రించండి మొత్తం శ్రేణి విలువలు
System.out.println ( ' \n శ్రేణి విలువల మొత్తం: ' + అవుట్‌పుట్ ) ;
}
}
అవుట్‌పుట్:
కోడ్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది. శ్రేణి యొక్క విలువలు మరియు శ్రేణి విలువల మొత్తం అవుట్‌పుట్‌లో ముద్రించబడతాయి:
ఉదాహరణ 2: వినియోగదారు నిర్వచించిన ఫంక్షన్‌ని ఉపయోగించడం
శ్రేణి విలువల మొత్తాన్ని లెక్కించడానికి మరొక మార్గం వినియోగదారు నిర్వచించిన ఫంక్షన్‌ను ఉపయోగించడం. ఐదు మూలకాల శ్రేణిని ప్రకటించే కింది కోడ్‌తో జావా ఫైల్‌ను సృష్టించండి, యాదృచ్ఛిక సంఖ్యలతో శ్రేణిని ప్రారంభించండి మరియు వినియోగదారు నిర్వచించిన ఫంక్షన్‌ని ఉపయోగించి శ్రేణి విలువల మొత్తాన్ని లెక్కించండి. మొత్తం విలువను లెక్కించడానికి కోడ్‌లో పునరావృత వినియోగదారు నిర్వచించిన ఫంక్షన్ ఉపయోగించబడుతుంది. తరువాత, మొత్తం విలువ ముద్రించబడుతుంది.
// యాదృచ్ఛిక మాడ్యూల్‌ను దిగుమతి చేయండిదిగుమతి java.util.Random;
పబ్లిక్ క్లాస్ SumOfArray2 {
// యొక్క శ్రేణిని ప్రకటించండి 5 అంశాలు
పబ్లిక్ స్టాటిక్ ఇంట్ numArr [ ] = కొత్త int [ 5 ] ;
// నిర్వచించండి ఫంక్షన్ లెక్కించేందుకు మొత్తం శ్రేణి విలువలు
పబ్లిక్ స్టాటిక్ పూర్ణాంక సమ్అరేవిలువలు ( మీరు l, మీరు [ ] రాక ) {
// ప్రస్తుత సూచిక విలువలను తనిఖీ చేయండి
ఉంటే ( l == 0 ) తిరిగి రాక [ ఎల్ ] ;
// కాల్ చేయండి ఫంక్షన్ స్వయంగా వరకు l విలువ అవుతుంది 0
తిరిగి రాక [ ఎల్ ] + SumArrayValues ( l- 1 , రావడం ) ;
}
పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
// చొప్పించు 5 శ్రేణిలోకి యాదృచ్ఛిక విలువలు
కోసం ( int i = 0 ; i < 5 ; i++ ) {
రాండమ్ r = కొత్త యాదృచ్ఛికం ( ) ;
numArr [ i ] = r.nextInt ( 99 ) ; ;
}
// కౌంట్ పరిమాణం శ్రేణి యొక్క
పూర్ణ లెన్ = numArr.length;
// శ్రేణిని తనిఖీ చేయండి పరిమాణం
ఉంటే ( మాత్రమే == 0 )
System.out.println ( 'శ్రేణి ఖాళీగా ఉంది.' ) ;
లేకపోతే
{
// శ్రేణి విలువలను ముద్రించండి
System.out.println ( 'శ్రేణి విలువలు:' ) ;
కోసం ( int i = 0 ; i < లెన్; i++ ) {
System.out.println ( numArr [ i ] ) ;
}
// కాల్ చేయండి ఫంక్షన్ లెక్కించేందుకు మొత్తం శ్రేణి విలువలు
int output = SumArrayValues ( కేవలం- 1 ,numArr ) ;
// ముద్రించండి మొత్తం శ్రేణి విలువలు
System.out.println ( ' \n పునరావృత ఫంక్షన్‌ని ఉపయోగించి శ్రేణి విలువల మొత్తం: ' + అవుట్‌పుట్ ) ;
}
}
}
అవుట్‌పుట్:
కోడ్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది. శ్రేణి యొక్క యాదృచ్ఛిక విలువలు మరియు శ్రేణి విలువల మొత్తం అవుట్‌పుట్‌లో ముద్రించబడతాయి:
ఉదాహరణ 3: సమ్() పద్ధతిని ఉపయోగించడం
శ్రేణి విలువల మొత్తాన్ని లెక్కించడానికి జావా స్టీమ్ API యొక్క మొత్తం() పద్ధతిని ఉపయోగించే కింది కోడ్‌తో జావా ఫైల్‌ను సృష్టించండి. కోడ్ ప్రారంభంలో ఐదు సంఖ్యల శ్రేణి నిర్వచించబడింది. తరువాత, శ్రేణి విలువల మొత్తాన్ని లెక్కించడానికి sum() పద్ధతి ఉపయోగించబడుతుంది.
// అవసరమైన మాడ్యూళ్లను దిగుమతి చేయండిదిగుమతి java.util.Random;
java.util.Arraysని దిగుమతి చేయండి;
పబ్లిక్ క్లాస్ SumOfArray3 {
// యొక్క శ్రేణిని ప్రకటించండి 5 అంశాలు
పబ్లిక్ స్టాటిక్ ఇంట్ numArr [ ] = కొత్త int [ 5 ] ;
పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
// చొప్పించు 5 శ్రేణిలోకి యాదృచ్ఛిక విలువలు
కోసం ( int i = 0 ; i < 5 ; i++ ) {
రాండమ్ r = కొత్త యాదృచ్ఛికం ( ) ;
numArr [ i ] = r.nextInt ( 99 ) ; ;
}
// కౌంట్ పరిమాణం శ్రేణి యొక్క
పూర్ణ లెన్ = numArr.length;
// శ్రేణిని తనిఖీ చేయండి పరిమాణం
ఉంటే ( మాత్రమే == 0 )
System.out.println ( 'శ్రేణి ఖాళీగా ఉంది.' ) ;
లేకపోతే
{
// శ్రేణి విలువలను ముద్రించండి
System.out.println ( 'శ్రేణి విలువలు:' ) ;
కోసం ( int i = 0 ; i < లెన్; i++ ) {
System.out.println ( numArr [ i ] ) ;
}
// కాల్ చేయండి ఫంక్షన్ లెక్కించేందుకు మొత్తం శ్రేణి విలువలు
int output = శ్రేణులు.స్ట్రీమ్ ( numArr ) .మొత్తం ( ) ;
// ముద్రించండి మొత్తం శ్రేణి విలువలు
System.out.println ( ' \n సమ్()ని ఉపయోగించే శ్రేణి విలువల మొత్తం: ' + అవుట్‌పుట్ ) ;
}
}
}
అవుట్‌పుట్:
కోడ్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది. శ్రేణి యొక్క యాదృచ్ఛిక విలువలు మరియు శ్రేణి విలువల మొత్తం అవుట్‌పుట్‌లో ముద్రించబడతాయి:
ముగింపు
జావాలోని శ్రేణి విలువల మొత్తాన్ని గణించే వివిధ మార్గాలు బహుళ ఉదాహరణలను ఉపయోగించి ఈ ట్యుటోరియల్‌లో చూపబడ్డాయి.