ప్రకటన:
శ్రేణులు “రకం[] ArrayName;” ఉపయోగించి ప్రకటించబడతాయి. సింటాక్స్‌లో రకం అనేది శ్రేణి సేకరణలోని సభ్యుల రకాన్ని సూచిస్తుంది మరియు “ArrName” అనేది శ్రేణికి కేటాయించబడిన శీర్షిక. శ్రేణి యొక్క డిక్లరేషన్ స్క్వేర్ బ్రాకెట్‌లతో సూచించబడుతుంది [].
రకం [ ] అర్రేపేరు = కొత్త రకం [ ] ; జాబితాలు “List
జాబితా < రకం > జాబితా పేరు = కొత్త జాబితా < రకం > ( ) ;
ప్రారంభించడం:
విలువలను జతచేయడానికి శ్రేణులు కర్లీ జంట కలుపులను {} ఉపయోగిస్తాయి, అయితే జాబితాలు విలువలను జతచేయడానికి కొత్త List
రకం [ ] అర్రేపేరు = { v1 , v2 , v3 , ... } ;
జాబితా < రకం > జాబితా పేరు = కొత్త జాబితా < రకం > { v1 , v2 , v3 , ... } ;
విలువలను జోడించడం:
C# శ్రేణులు నిర్దిష్ట పరిమాణాన్ని కలిగి ఉన్నాయని గుర్తుంచుకోవడం చాలా ముఖ్యం. వేరే పరిమాణం అవసరమైతే, కావలసిన పరిమాణంతో (ప్రస్తుత పొడవు + కొత్త విలువల సంఖ్య) కొత్త శ్రేణి “newArr”ని సృష్టించాలి. కొత్త శ్రేణికి అసలు శ్రేణి “OrgArr”ని జోడించండి మరియు కొత్త శ్రేణిలోని కొత్త స్థానాలకు కొత్త విలువలను కేటాయించండి మరియు కొత్త శ్రేణికి సూచనను నవీకరించండి.
అమరిక. కాపీ చేయండి ( OrgArr , newArr , OrgArr. పొడవు ) ;
newArr [ OrgArr. పొడవు ] = 14 ; // కొత్త విలువ
newArr [ OrgArr. పొడవు + 1 ] = 2 ; // కొత్త విలువ
OrgArr = newArr ; // రిఫరెన్స్ పూర్ణాన్ని నవీకరించండి[] NewArr = కొత్త int[OrgArr.Length + 2];
జాబితాలు పరిమాణం నిర్వహణ పరంగా వశ్యతను అందిస్తాయి. జాబితా ప్రారంభించబడినప్పుడు, అది ప్రారంభ సామర్థ్యంతో ప్రారంభమవుతుంది, అయితే మరిన్ని అంశాలు జోడించబడినందున అది స్వయంచాలకంగా విస్తరించవచ్చు. ఈ డైనమిక్ రీసైజింగ్ సామర్ధ్యం మారుతున్న అవసరాలకు అనుగుణంగా జాబితాలను అనుమతిస్తుంది. C# జాబితాలు జాబితాకు విలువలను జోడించడానికి Add() ఫంక్షన్‌ను అందిస్తాయి. మీరు C# జాబితాకు విలువలను ఎలా జోడించవచ్చో ఇక్కడ ఉంది:
శ్రేణులు vs జాబితాలు : C లో వినియోగ పోలిక #
విలువలను యాక్సెస్ చేస్తోంది
శ్రేణి సంఖ్యలలోని విలువలు ఇండెక్స్ సంజ్ఞామానం []ని ఉపయోగించి ప్రాప్తి చేయబడతాయి, అనగా బ్రాకెట్‌లలోని సూచిక సంఖ్యను ఉపయోగించడం మరియు మరొక వేరియబుల్‌లో సేవ్ చేయబడుతుంది.
రకం మూలకం = అర్రేపేరు [ సూచిక ] ;C# జాబితాలోని విలువలను యాక్సెస్ చేయడానికి, మీరు శ్రేణుల మాదిరిగానే కావలసిన ఇండెక్స్ స్థానంతో పాటు ఇండెక్స్ సంజ్ఞామానాన్ని కూడా ఉపయోగించవచ్చు.
రకం మూలకం = జాబితా పేరు [ సూచిక ] ;
విలువలను తొలగించడం
శ్రేణులు సెట్ పొడవును కలిగి ఉంటాయి. అందువల్ల, మూలకాలను తీసివేయడానికి, తక్కువ పరిమాణంతో కొత్త శ్రేణిని సృష్టించాలి మరియు ఇప్పటికే ఉన్న మూలకాలను తప్పనిసరిగా కాపీ చేయాలి. 'విలువలను జోడించడం' విభాగంలో వివరించిన విధంగా Array.Copy() ఫంక్షన్‌ని ఉపయోగించడం ద్వారా ఇది చేయవచ్చు. C# జాబితాలలో, విలువలను తీసివేయడం చాలా సులభం మరియు మరింత స్పష్టమైనది. జాబితా
విలువలను లెక్కించండి
C# శ్రేణిలోని విలువలను లెక్కించడానికి, మీరు శ్రేణి పొడవు లక్షణాన్ని ఉపయోగించవచ్చు. పొడవు ప్రాపర్టీ మీకు శ్రేణిలోని మొత్తం విలువల సంఖ్యను అందిస్తుంది.
int లెక్కించండి = శ్రేణి పేరు. పొడవు ;C# జాబితాలోని విలువలను లెక్కించడానికి, మీరు జాబితా యొక్క “కౌంట్” లక్షణాన్ని ఉపయోగించవచ్చు. జాబితాలో ప్రస్తుతం ఉన్న మూలకాల మొత్తం కూడా అదే విధంగా “కౌంట్” లక్షణం ద్వారా అందించబడుతుంది.
int లెక్కించండి = జాబితా పేరు. లెక్కించు ;విలువలను పునరావృతం చేయండి
C# శ్రేణిలో విలువలను మళ్ళించడానికి, మీరు లూప్ కండిషన్‌గా శ్రేణి పొడవుతో “ఫర్” లూప్‌ని ఉపయోగించవచ్చు.
కోసం ( int i = 0 ; i < అర్రేపేరు. పొడవు ; i ++ ) {రకం ఇ = శ్రేణి పేరు [ i ] ;
కన్సోల్. రైట్ లైన్ ( అది ) ;
}
C# జాబితాలోని విలువలను మళ్ళించడానికి, మూలకాలపై స్వయంచాలకంగా పునరావృతం చేయడం ద్వారా పునరావృత ప్రక్రియను సులభతరం చేయడంతో మీరు 'ఫోరీచ్' లూప్‌ని ఉపయోగించవచ్చు.
ప్రతి ( జాబితా పేరులో ఇ అని టైప్ చేయండి ) {కన్సోల్. రైట్ లైన్ ( అది ) ;
}
ఉదాహరణ 1: C# అర్రేలు
ఇచ్చిన కోడ్ 5 పొడవుతో “Arr” అనే పేరుగల పూర్ణాంక శ్రేణిని ప్రకటిస్తుంది మరియు ప్రారంభిస్తుంది మరియు దాని మూలకాలకు విలువలను కేటాయిస్తుంది. శ్రేణి మూలకాలకు కేటాయించిన విలువలు 11, 12, 13, 14 మరియు 15. ఆ తర్వాత కోడ్ 'ఫర్' లూప్‌ని ఉపయోగించి శ్రేణి యొక్క మూలకాలను ప్రదర్శించడానికి కొనసాగుతుంది. ప్రతి భాగం Console.WriteLine() పద్ధతిని ఉపయోగించి ఒక ప్రత్యేక లైన్‌లో ప్రదర్శించబడుతుంది.
అసలైన మూలకాలను ప్రదర్శించిన తర్వాత, కోడ్ కొత్త విలువ 10తో కేటాయించడం ద్వారా ఇండెక్స్ 2 వద్ద మూలకాన్ని సవరిస్తుంది. తర్వాత, కోడ్ “ఫర్” లూప్‌ని ఉపయోగించి మళ్లీ మూలకాల ద్వారా మళ్లించడం ద్వారా సవరించిన శ్రేణిని ప్రదర్శిస్తుంది. చివరగా, శ్రేణి యొక్క పొడవును అందించే “Arr.Length” లక్షణాన్ని ఉపయోగించి శ్రేణిలో ఉండే మొత్తం విలువల సంఖ్యను కోడ్ ప్రదర్శిస్తుంది.
సిస్టమ్ ఉపయోగించి ;తరగతి డమ్మీ {
స్థిరమైన శూన్యం ప్రధాన ( ) {
int [ ] అర్ = కొత్త int [ 5 ] { పదకొండు , 12 , 13 , 14 , పదిహేను } ;
కన్సోల్. రైట్ లైన్ ( 'మూలకాలు:' ) ;
కోసం ( int i = 0 ; i < అర్. పొడవు ; i ++ )
{
కన్సోల్. రైట్ లైన్ ( అర్ [ i ] ) ;
}
అర్ [ 2 ] = 10 ;
కన్సోల్. రైట్ లైన్ ( 'సవరించిన శ్రేణి:' ) ;
కోసం ( int i = 0 ; i < అర్. పొడవు ; i ++ )
{
కన్సోల్. రైట్ లైన్ ( అర్ [ i ] ) ;
}
కన్సోల్. రైట్ లైన్ ( 'మూలకాల సంఖ్య:' + అర్. పొడవు ) ;
}
}
ఉదాహరణ 2: C# జాబితాలు
కింది అందించిన కోడ్ పూర్ణాంకాల సేకరణను నిల్వ చేయడానికి మరియు మార్చడానికి C# జాబితా వినియోగాన్ని ప్రదర్శిస్తుంది. మొదట, కోడ్ ఐదు పూర్ణాంకాలతో 'Arr' అనే జాబితాను ప్రారంభిస్తుంది: 11, 12, 13, 14 మరియు 15. ఇది జాబితా
తర్వాత, ప్రోగ్రామ్ “ఎలిమెంట్స్:” సందేశాన్ని ప్రింట్ చేస్తుంది మరియు “ఫోరీచ్” లూప్‌ని ఉపయోగించి జాబితాలోని ప్రతి మూలకంపై మళ్ళిస్తుంది. ప్రతి పునరావృతం సమయంలో, ప్రస్తుత మూలకం Console.WriteLine() పద్ధతిని ఉపయోగించి కన్సోల్‌కు ముద్రించబడుతుంది.
తరువాత, కోడ్ 10 (Arr[2] = 10) విలువతో కేటాయించడం ద్వారా జాబితా యొక్క సూచిక 2 వద్ద విలువను సవరించింది. ఈ పంక్తి జాబితాలోని మూడవ మూలకాన్ని 13 నుండి 10కి మారుస్తుంది. సవరణను అనుసరించి, ప్రోగ్రామ్ మళ్లీ 'మార్చబడిన జాబితా:' సందేశాన్ని ముద్రిస్తుంది మరియు నవీకరించబడిన జాబితాపై పునరావృతమవుతుంది, ప్రతి మూలకాన్ని కన్సోల్‌కు ముద్రిస్తుంది. ఆ తర్వాత కోడ్ 'Arr.Count'ని ఉపయోగించి జాబితాలోని విలువల సంఖ్యను ప్రదర్శిస్తుంది. ఈ లక్షణం జాబితాలో ఉన్న అంశాల గణనను అందిస్తుంది, ఈ క్రింది దృష్టాంతంలో, 5 ఉంటుంది.
చివరగా, కోడ్ Arr.Remove(4) పద్ధతిని ఉపయోగించి జాబితా నుండి 4 విలువ కలిగిన మూలకాన్ని తొలగిస్తుంది. ఈ పద్ధతి జాబితాలో పేర్కొన్న విలువ కోసం శోధిస్తుంది మరియు దాని మొదటి సంఘటనను తొలగిస్తుంది. చివరగా, ప్రోగ్రామ్ “తొలగింపు తర్వాత జాబితా:” సందేశాన్ని ప్రింట్ చేస్తుంది మరియు తొలగింపు ఆపరేషన్ తర్వాత మిగిలిన ప్రతి మూలకాన్ని ప్రదర్శిస్తూ జాబితాపై మరోసారి పునరావృతమవుతుంది.
సిస్టమ్ ఉపయోగించి ;సిస్టమ్ ఉపయోగించి. సేకరణలు . సాధారణమైనది ;
తరగతి డమ్మీ {
స్థిరమైన శూన్యం ప్రధాన ( ) {
జాబితా < int > అర్ = కొత్త జాబితా < int > ( ) { పదకొండు , 12 , 13 , 14 , పదిహేను } ;
కన్సోల్. రైట్ లైన్ ( 'మూలకాలు:' ) ;
ప్రతి ( int n Arr లో )
{
కన్సోల్. రైట్ లైన్ ( n ) ;
}
అర్ [ 2 ] = 10 ;
కన్సోల్. రైట్ లైన్ ( 'సవరించిన జాబితా:' ) ;
ప్రతి ( int n Arr లో )
{
కన్సోల్. రైట్ లైన్ ( n ) ;
}
కన్సోల్. రైట్ లైన్ ( 'మూలకాల సంఖ్య:' + అర్. లెక్కించు ) ;
అర్. తొలగించు ( 4 ) ;
కన్సోల్. రైట్ లైన్ ( 'తొలగించిన తర్వాత జాబితా:' ) ;
ప్రతి ( int n Arr లో )
{
కన్సోల్. రైట్ లైన్ ( n ) ;
}
}
}
ముగింపు
ఈ గైడ్ C# శ్రేణులు మరియు C# జాబితాల మధ్య ప్రాథమిక సింటాక్స్ తేడాలను కవర్ చేస్తుంది. శ్రేణులు స్థిరమైన పొడవును కలిగి ఉంటాయి మరియు సూచిక ద్వారా యాక్సెస్ చేయబడతాయి, అయితే జాబితాలు డైనమిక్ పరిమాణంలో ఉంటాయి మరియు మూలకాలను జోడించడానికి మరియు తీసివేయడానికి అదనపు పద్ధతులను అందిస్తాయి. దానితో పాటు, మేము డిక్లరేషన్, ప్రారంభించడం, యాక్సెస్ చేయడం, సవరించడం, లెక్కించడం మరియు మూలకాలను జోడించడం వంటి వాటిని ప్రదర్శించే C# జాబితా ప్రోగ్రామ్‌లను అందించాము.