ఈ గైడ్‌లో, మేము '' యొక్క తేడాలు మరియు ప్రయోజనాల గురించి మాట్లాడుతాము. శ్రేణులు 'మరియు' జాబితాలు ”సి#లో.
C#లో శ్రేణులు
శ్రేణులు ఒకే రకమైన డేటాను స్థిర మెమరీలో నిల్వ చేస్తాయి. ది ' సిస్టమ్.అరే ”అరే కోసం నేమ్‌స్పేస్ ఉపయోగించబడుతుంది. డేటాను నిల్వ చేయడానికి శ్రేణిలో సూచికలు ఉన్నాయి. శ్రేణి యొక్క మార్చలేని పరిమాణం కారణంగా, మెమరీ వృధా సమస్య. శ్రేణులు స్థిరంగా మరియు నిరంతరాయంగా ఉంటాయి మరియు శ్రేణిని ఉపయోగించడం వల్ల కలిగే ప్రయోజనం ఏమిటంటే దాని అమలు వేగంగా ఉంటుంది.
శ్రేణి యొక్క వాక్యనిర్మాణం:
సమాచార తరహా [ ] శ్రేణి పేరు ;
శ్రేణి యొక్క ఉదాహరణను చూద్దాం:
సిస్టమ్ ఉపయోగించి ;
namespace CSharpArrayExample
{
పబ్లిక్ క్లాస్ పేర్లు
{
స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ )
{
స్ట్రింగ్ [ ] పేర్లు = { 'లేదా' , 'బుష్రా' , 'ప్రారంభం' , 'ఫవాద్' } ;
కన్సోల్. రైట్ లైన్ ( 'సూచిక 1లోని మూలకం:' + పేర్లు [ 1 ] ) ;
కన్సోల్. రైట్ లైన్ ( 'శ్రేణి యొక్క మూలకాలు:' ) ;
కోసం ( int సూచిక = 0 ; సూచిక < పేర్లు. పొడవు ; సూచిక ++ )
{
కన్సోల్. రైట్ లైన్ ( పేర్లు [ సూచిక ] ) ;
}
కన్సోల్. రీడ్‌కీ ( ) ;
}
}
}
పైన వివరించిన ఉదాహరణలో:
- ముందుగా, '' పేరుతో అవసరమైన నేమ్‌స్పేస్ లైబ్రరీలను జోడించండి వ్యవస్థ 'మరియు' SharpArray ఉదాహరణ ”.
- అప్పుడు, '' పేరుతో తరగతిని ప్రకటించండి పేర్లు ” దీనిలో మేము పేర్లను నిల్వ చేసి ప్రదర్శించాలనుకుంటున్నాము.
- తరువాత, మేము పేర్లను నిల్వ చేసిన ప్రధాన పద్ధతిలో స్ట్రింగ్ శ్రేణిని ప్రకటించండి.
- ఆ తర్వాత, ముందుగా, మేము ఇండెక్స్ 1 వద్ద ఒక మూలకాన్ని ప్రింట్ చేస్తాము, ఇది పేర్కొన్న ఇండెక్స్ వద్ద శ్రేణి యొక్క మూలకాన్ని ఎలా యాక్సెస్ చేయవచ్చో చూపుతుంది.
- అప్పుడు, మేము మొత్తం శ్రేణిని ప్రింట్ చేస్తాము.
అవుట్పుట్ క్రింది విధంగా ఉంది:
C#లో జాబితా
'జాబితా' లో ఉంది System.Collection.Generic మరియు సాధారణ రకం. “జాబితాలు” డైనమిక్ స్వభావం కలిగి ఉంటాయి మరియు ఎలిమెంట్‌లను జోడించడానికి, తీసివేయడానికి, చొప్పించడానికి, తొలగించడానికి లేదా మార్చడానికి ఒకరిని అనుమతిస్తాయి. C#లో మూలకం జోడించబడినా లేదా తీసివేయబడినా జాబితా స్వయంచాలకంగా పరిమాణం మార్చబడుతుంది.
C#లోని జాబితా కోసం వాక్యనిర్మాణం క్రింద పేర్కొనబడింది:
జాబితా < రకం > పేరు = కొత్త జాబితా < రకం > ( ) ;మంచి అవగాహన కోసం క్రింది ఉదాహరణను చూద్దాం:
సిస్టమ్ ఉపయోగించి ;సిస్టమ్ ఉపయోగించి. సేకరణలు . సాధారణమైనది ;
నేమ్‌స్పేస్ పేర్లు
{
పబ్లిక్ క్లాస్ పేర్లు
{
స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ )
{
జాబితా < స్ట్రింగ్ > పేర్లు = కొత్త జాబితా < స్ట్రింగ్ > ( ) ;
పేర్లు. జోడించు ( 'లేదా' ) ;
పేర్లు. జోడించు ( 'బుష్రా' ) ;
పేర్లు. జోడించు ( 'ప్రారంభం' ) ;
పేర్లు. జోడించు ( 'ఫవాద్' ) ;
కన్సోల్. రైట్ లైన్ ( 'సూచిక 1లోని మూలకం:' + పేర్లు [ 1 ] ) ;
కన్సోల్. రైట్ లైన్ ( 'ఈ జాబితాలోని అంశాలు:' ) ;
కోసం ( int సూచిక = 0 ; సూచిక < పేర్లు. లెక్కించు ; సూచిక ++ )
{
కన్సోల్. రైట్ లైన్ ( పేర్లు [ సూచిక ] ) ;
}
కన్సోల్. రీడ్‌కీ ( ) ;
}
}
}
ఈ ప్రోగ్రామ్ యొక్క పని శ్రేణి ఉదాహరణ వలె ఉంటుంది. అయితే, మేము జాబితాను ఉపయోగించి డేటాను నిల్వ చేస్తాము.
అవుట్పుట్
C#లో “అరే” మరియు “జాబితా” మధ్య తేడాలు
ఇప్పుడు, C#లోని శ్రేణి మరియు జాబితా మధ్య తేడాలను శీఘ్రంగా చూద్దాం:
| ఆస్తి | అమరిక | జాబితా |
| ప్రకృతి | స్థిరమైన | డైనమిక్ |
| జ్ఞాపకశక్తి | స్థిర మెమరీ, కాబట్టి మెమరీ వృధా సంభవించవచ్చు. | మెమరీ వృధా జరగదు |
| అమలు | వేగంగా | నెమ్మదిగా |
| వ్యక్తిగత మూలకాన్ని యాక్సెస్ చేస్తోంది | వేగంగా | నెమ్మదిగా |
| మూలకాన్ని జోడించండి మరియు తీసివేయండి | నెమ్మదిగా | వేగంగా |
C#లో అర్రే యొక్క ప్రయోజనాలు
శ్రేణుల ప్రయోజనాలు:
- శ్రేణులను సులభంగా ఆప్టిమైజ్ చేయవచ్చు.
- వినియోగదారులు ఒకే రకమైన డేటా రకం యొక్క అనేక అంశాలను సేవ్ చేయవచ్చు.
- అమలు వేగంగా ఉంది.
- మేము ఒక నిర్దిష్ట సూచిక వద్ద మూలకాన్ని యాక్సెస్ చేయవచ్చు.
- ఇది మూలకాల కోసం శోధించడానికి అనుమతిస్తుంది.
- మెరుగైన పనితీరు.
- తక్కువ రన్‌టైమ్ లోపాలు.
C#లో జాబితా యొక్క ప్రయోజనాలు
జాబితాలను ఉపయోగించడం వల్ల కలిగే ప్రయోజనాలు:
- స్థిరమైన మెమరీ లేదు.
- డిక్లరేషన్ తర్వాత స్కేల్ చేయవచ్చు.
- మూలకాలను జోడించడం మరియు తీసివేయడం వేగంగా జరుగుతుంది.
- డేటాను మానిప్యులేట్ చేయడానికి మమ్మల్ని అనుమతించండి.
- మేము పేర్కొన్న సూచికలో మూలకాలను యాక్సెస్ చేయవచ్చు.
మేము C#లోని “శ్రేణి” మరియు “జాబితా” మధ్య ప్రయోజనాలు మరియు తేడాలను చర్చించాము.
ముగింపు
డేటాను నిల్వ చేయడానికి శ్రేణులు మరియు జాబితాలు ఉపయోగించబడతాయి. శ్రేణులు స్థిర రకాలు మరియు మెమరీని కలిగి ఉంటాయి మరియు మూలకాలను శోధించడానికి లేదా యాక్సెస్ చేయడానికి మమ్మల్ని అనుమతిస్తాయి. జాబితాలు డైనమిక్ రకానికి చెందినవి మరియు స్థిరమైన మెమరీని కలిగి ఉండవు మరియు డేటాను చొప్పించడానికి, తొలగించడానికి లేదా మానిప్యులేట్ చేయడానికి మమ్మల్ని అనుమతిస్తాయి. ఈ గైడ్‌లో, మేము C#లోని “శ్రేణి” మరియు “జాబితా” యొక్క తేడాలు మరియు ప్రయోజనాలను చూశాము.