C#లో, శ్రేణులు ఒకే డేటా రకం మూలకాలను నిల్వ చేయడానికి కంటైనర్‌లుగా పనిచేస్తాయి. శ్రేణిని సృష్టించేటప్పుడు, మూలకాలతో దాన్ని ప్రారంభించేందుకు బహుళ విధానాలు ఉన్నాయి. ఈ వ్యాసం C#లో శ్రేణులను ప్రారంభించే వివిధ పద్ధతులను పరిశీలిస్తుంది, ప్రతి విధానం యొక్క సమగ్ర అన్వేషణను అందిస్తుంది.
C#లో శ్రేణులను ప్రారంభించే పద్ధతులు
కంప్యూటర్ ప్రోగ్రామింగ్‌లో శ్రేణులు ఒక ముఖ్యమైన డేటా నిర్మాణం, ఇవి ఒకే రకమైన డేటా రకానికి చెందిన మూలకాల సేకరణను సమీప మెమరీ స్థానాల్లో నిల్వ చేయడానికి మరియు మార్చడానికి మిమ్మల్ని అనుమతిస్తుంది. C#లో శ్రేణులను ప్రారంభించేందుకు ఇక్కడ కొన్ని మార్గాలు ఉన్నాయి:
1: అర్రే ఇనిషియలైజర్ సింటాక్స్ ఉపయోగించి అర్రేలను ప్రారంభించడం
శ్రేణిని ప్రారంభించేందుకు అత్యంత సరళమైన విధానం అర్రే ఇనిషియలైజర్ సింటాక్స్‌ను ఉపయోగించడం, ఇది కామాలతో వేరు చేయబడిన జంట కలుపులలో శ్రేణి మూలకాలను చేర్చడం, ఉదాహరణకు:
int [ ] సంఖ్యలు = { 1 , 2 , 3 , 4 , 5 } ;
ఈ కోడ్‌లో, 'సంఖ్యలు' అనే పేరుగల పూర్ణాంక శ్రేణి 1 నుండి 5 విలువలతో సృష్టించబడుతుంది మరియు ప్రారంభించబడుతుంది. అదేవిధంగా, మీరు బహుమితీయ శ్రేణిని ప్రారంభించేందుకు అదే సింటాక్స్‌ని ఉపయోగించవచ్చు.
int [ , ] myMultiDimensionalArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
C#లో 1D మరియు 2D శ్రేణిని ప్రారంభించేందుకు ఇనిషియలైజర్ సింటాక్స్‌ని ఉపయోగించే ఉదాహరణ కోడ్ ఇక్కడ ఉంది:
వ్యవస్థను ఉపయోగించడం;
తరగతి శ్రేణి
{
స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ )
{
// ఇనిషియలైజర్ సింటాక్స్ ఉపయోగించి 1D శ్రేణిని ప్రారంభించడం
int [ ] శ్రేణి1D = { 1 , 2 , 3 , 4 , 5 } ;
కన్సోల్.WriteLine ( 'array1Dలో విలువలు:' ) ;
కోసం ( int i = 0 ; i < శ్రేణి1D.పొడవు; i++ ) {
కన్సోల్.WriteLine ( శ్రేణి1D [ i ] ) ;
}
// ఇనిషియలైజర్ సింటాక్స్ ఉపయోగించి 2D శ్రేణిని ప్రారంభించడం
int [ , ] శ్రేణి2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
కన్సోల్.WriteLine ( 'array2Dలో విలువలు:' ) ;
కోసం ( int i = 0 ; i < array2D.GetLength ( 0 ) ; i++ ) {
కోసం ( int j = 0 ; j < array2D.GetLength ( 1 ) ; j++ ) {
కన్సోల్.WriteLine ( '({0}, {1}): {2}' , i, j, array2D [ i, j ] ) ;
}
}
}
}
ఈ కోడ్‌లో, మేము 1, 2, 3, 4 మరియు 5 విలువలతో array1D అని పిలువబడే 1-డైమెన్షనల్ పూర్ణాంక శ్రేణిని ప్రారంభించేందుకు ఇనిషియలైజర్ సింటాక్స్‌ని ఉపయోగిస్తున్నాము.
మేము {1, 2}, {3, 4} మరియు {5, 6} విలువలతో array2D అని పిలువబడే 2-డైమెన్షనల్ పూర్ణాంక శ్రేణిని ప్రారంభించేందుకు ఇనిషియలైజర్ సింటాక్స్‌ని కూడా ఉపయోగిస్తున్నాము.
మేము ప్రతి శ్రేణిలోని ప్రతి మూలకం ద్వారా పునరావృతం చేయడానికి మరియు దాని విలువను కన్సోల్‌కు ప్రింట్ చేయడానికి లూప్‌ల కోసం అదనంగా ఉపయోగిస్తాము.
2: కొత్త కీవర్డ్‌ని ఉపయోగించి శ్రేణులను ప్రారంభించడం
శ్రేణిని ప్రారంభించడం కోసం అదనపు పద్ధతిని ఉపయోగించడాన్ని కలిగి ఉంటుంది కొత్త కీవర్డ్. ఇది స్క్వేర్ బ్రాకెట్లలో శ్రేణి యొక్క పరిమాణాన్ని పేర్కొనడం, దాని తర్వాత కొత్త కీవర్డ్, ఆపై శ్రేణి మూలకాల యొక్క డేటా రకాన్ని పేర్కొనడం. ఉదాహరణకి:
int [ ] సంఖ్యలు = కొత్త పూర్ణాంకము [ 5 ] ;
ఈ కోడ్ 5 పరిమాణంతో సంఖ్యల పేరుతో పూర్ణాంక శ్రేణిని సృష్టిస్తుంది మరియు అన్ని మూలకాలను వాటి డిఫాల్ట్ విలువకు ప్రారంభిస్తుంది, ఇది పూర్ణాంక శ్రేణుల కోసం 0.
C#లోని కొత్త కీవర్డ్‌ని ఉపయోగించి బహుమితీయ శ్రేణిని ప్రారంభించడం కోసం సింటాక్స్ ఇక్కడ ఉంది:
< రకం > [ , ] < శ్రేణి పేరు > = కొత్త < రకం > [ < పొడవు1 > , < పొడవు2 > ,... ] { { < ప్రారంభ విలువలు > } } ;
ఈ సింటాక్స్‌లో,
2-డైమెన్షనల్ పూర్ణాంక శ్రేణిని ప్రారంభించడానికి ఈ వాక్యనిర్మాణాన్ని ఎలా ఉపయోగించాలో ఇక్కడ ఒక ఉదాహరణ ఉంది:
int [ , ] myArray = కొత్త int [ 3 , 2 ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
ఈ ఉదాహరణలో, మేము కొత్త కీవర్డ్‌ని ఉపయోగించి 3 అడ్డు వరుసలు మరియు 2 నిలువు వరుసలతో myArray అనే 2d పూర్ణాంక శ్రేణిని ప్రారంభిస్తున్నాము. మేము డబుల్ కర్లీ బ్రేస్‌ల సింటాక్స్‌ని ఉపయోగించి శ్రేణిలోని ప్రతి మూలకం కోసం ప్రారంభ విలువలను కూడా అందిస్తున్నాము. విలువలు {1, 2}, {3, 4} మరియు {5, 6}, ప్రతి అడ్డు వరుసలోని మూలకాలకు అనుగుణంగా ఉంటాయి.
ప్రతి శ్రేణిలోని విలువలను ప్రింట్ చేయడానికి కోడ్‌తో పాటు C#లో 1-డైమెన్షనల్ మరియు 2-డైమెన్షనల్ శ్రేణిని ప్రారంభించడం కోసం కొత్త కీవర్డ్‌ని ఎలా ఉపయోగించాలో ఇక్కడ ఒక ఉదాహరణ ఉంది:
వ్యవస్థను ఉపయోగించడం;తరగతి శ్రేణి
{
స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ )
{
// ప్రారంభించడం a 1 -డైమెన్షనల్ శ్రేణి
int [ ] myArray1D = కొత్త Int [ ] { 1 , 2 , 3 , 4 , 5 } ;
కన్సోల్.WriteLine ( 'myArray1Dలో విలువలు:' ) ;
కోసం ( int i = 0 ; i < myArray1D.Length; i++ )
{
కన్సోల్.WriteLine ( myArray1D [ i ] ) ;
}
// ప్రారంభించడం a 2 -డైమెన్షనల్ శ్రేణి
int [ , ] myArray2D = కొత్త Int [ , ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
కన్సోల్.WriteLine ( 'myArray2Dలో విలువలు:' ) ;
కోసం ( int i = 0 ; i < myArray2D.GetLength ( 0 ) ; i++ )
{
కోసం ( int j = 0 ; జె < myArray2D.GetLength ( 1 ) ; j++ )
{
కన్సోల్.WriteLine ( '({0}, {1}): {2}' , i, j, myArray2D [ i, j ] ) ;
}
}
}
}
ఈ కోడ్‌లో, మేము ఒక డైమెన్షనల్ పూర్ణాంక శ్రేణిని ప్రారంభించేందుకు కొత్త కీవర్డ్‌ని ఉపయోగిస్తున్నాము myArray1D 1, 2, 3, 4, మరియు 5 విలువలు మరియు 2-డైమెన్షనల్ పూర్ణాంక శ్రేణి అని పిలుస్తారు myArray2D {1, 2}, {3, 4} మరియు {5, 6} విలువలతో.
మేము ప్రతి శ్రేణిలోని ప్రతి మూలకం ద్వారా పునరావృతం చేయడానికి మరియు దాని విలువను కన్సోల్‌కు ప్రింట్ చేయడానికి లూప్‌ల కోసం ఉపయోగిస్తాము. 2-డైమెన్షనల్ అర్రే కోసం, మేము ఉపయోగిస్తున్నామని గమనించండి పొడవు() అడ్డు వరుసలు మరియు నిలువు వరుసల సంఖ్యను నిర్ణయించడానికి మరియు ప్రతి మూలకం ద్వారా పునరావృతం చేయడానికి లూప్‌ల కోసం నెస్టెడ్‌ని ఉపయోగించడం.
3: లూప్‌లను ఉపయోగించి అర్రేలను ప్రారంభించడం
లూప్‌లను ఉపయోగించి శ్రేణులను కూడా ప్రారంభించవచ్చు. లూప్ కోసం లూప్‌ని ఉపయోగించడం ఒక విధానం, ఇది శ్రేణి ద్వారా పునరావృతం చేయడానికి మరియు ప్రతి మూలకానికి విలువలను కేటాయించడానికి మిమ్మల్ని అనుమతిస్తుంది.
int [ ] సంఖ్యలు = కొత్త పూర్ణాంకము [ 5 ] ;కోసం ( int i = 0 ; i < సంఖ్యలు.పొడవు; i++ )
{
సంఖ్యలు [ i ] = నేను + 1 ;
}
ఈ కోడ్ 5 పరిమాణంతో సంఖ్యల పేరుతో పూర్ణాంక శ్రేణిని సృష్టిస్తుంది మరియు ప్రతి మూలకానికి దాని ఇండెక్స్ ప్లస్ 1కి సమానమైన విలువను కేటాయిస్తుంది. లూప్‌లను ఉపయోగించి C#లో 2-డైమెన్షనల్ పూర్ణాంక శ్రేణిని ఎలా ప్రారంభించాలో ఇక్కడ ఒక ఉదాహరణ ఉంది:
కోసం ( int i = 0 ; i < 3 ; i++ )
{
కోసం ( int j = 0 ; జె < 2 ; j++ )
{
నాఅరే [ i, j ] = i + j;
}
}
ఈ ఉదాహరణలో, మేము 2-డైమెన్షనల్ పూర్ణాంక శ్రేణి యొక్క ప్రతి మూలకం ద్వారా పునరావృతం చేయడానికి లూప్‌ల కోసం నెస్టెడ్‌ని ఉపయోగిస్తున్నాము నాఅరే , ఇందులో 3 అడ్డు వరుసలు మరియు 2 నిలువు వరుసలు ఉన్నాయి. ప్రతి మూలకం కోసం, మేము i + j వ్యక్తీకరణను ఉపయోగించి దాని అడ్డు వరుస మరియు నిలువు వరుస సూచికల మొత్తానికి దాని విలువను సెట్ చేస్తున్నాము.
ప్రతి శ్రేణిలోని విలువలను ప్రింట్ చేయడానికి కోడ్‌తో పాటు C#లో 1-డైమెన్షనల్ మరియు 2-డైమెన్షనల్ శ్రేణిని ప్రారంభించేందుకు లూప్‌లను ఎలా ఉపయోగించాలో ఇక్కడ ఒక ఉదాహరణ ఉంది:
వ్యవస్థను ఉపయోగించడం;తరగతి శ్రేణి
{
స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ )
{
// ప్రారంభించడం a 1 లూప్ ఉపయోగించి డైమెన్షనల్ అర్రే
int [ ] myArray1D = కొత్త Int [ 5 ] ;
కోసం ( int i = 0 ; i < myArray1D.Length; i++ )
{
myArray1D [ i ] = నేను + 1 ;
}
కన్సోల్.WriteLine ( 'myArray1Dలో విలువలు:' ) ;
కోసం ( int i = 0 ; i < myArray1D.Length; i++ )
{
కన్సోల్.WriteLine ( myArray1D [ i ] ) ;
}
// ప్రారంభించడం a 2 సమూహ లూప్‌లను ఉపయోగించి డైమెన్షనల్ అర్రే
int [ , ] myArray2D = కొత్త Int [ 3 , 2 ] ;
కోసం ( int i = 0 ; i < 3 ; i++ )
{
కోసం ( int j = 0 ; జె < 2 ; j++ )
{
myArray2D [ i, j ] = i + j;
}
}
కన్సోల్.WriteLine ( 'myArray2Dలో విలువలు:' ) ;
కోసం ( int i = 0 ; i < 3 ; i++ )
{
కోసం ( int j = 0 ; జె < 2 ; j++ )
{
కన్సోల్.WriteLine ( '({0}, {1}): {2}' , i, j, myArray2D [ i, j ] ) ;
}
}
}
}
ఈ కోడ్‌లో, 1, 2, 3, 4 మరియు 5 విలువలతో myArray1D అని పిలువబడే 1-డైమెన్షనల్ పూర్ణాంక శ్రేణిని ప్రారంభించేందుకు మేము for loopని ఉపయోగిస్తున్నాము. మేము 2-డైమెన్షనల్ పూర్ణాంక శ్రేణిని ప్రారంభించేందుకు లూప్‌ల కోసం నెస్టెడ్‌ని కూడా ఉపయోగిస్తున్నాము. myArray2D విలువలతో {0, 1}, {1, 2} మరియు {2, 3} i + j వ్యక్తీకరణను ఉపయోగిస్తుంది.
ప్రతి శ్రేణిలోని ప్రతి మూలకం ద్వారా మళ్ళించడానికి మరియు దాని విలువను కన్సోల్‌కు ప్రింట్ చేయడానికి లూప్‌ల కోసం అదనపు ఉపయోగించండి.
4: Array.Copy()ని ఉపయోగించి శ్రేణులను ప్రారంభించడం
శ్రేణిని ప్రారంభించే ప్రత్యామ్నాయ విధానం Array.Copy() ఫంక్షన్‌ను ఉపయోగించడం. ఇది కావలసిన మూలకాలతో మూలాధార శ్రేణిని సృష్టించడం మరియు వాటిని లక్ష్య శ్రేణికి కాపీ చేయడం. ఉదాహరణకి:
int [ ] మూలం = { 1 , 2 , 3 , 4 , 5 } ;int [ ] లక్ష్యం = కొత్త పూర్ణాంకం [ మూలం.పొడవు ] ;
అర్రే.కాపీ ( మూలం , లక్ష్యం, మూలం.పొడవు ) ;
ఈ కోడ్ 1 నుండి 5 విలువలతో సోర్స్ పేరుతో పూర్ణాంక శ్రేణిని సృష్టిస్తుంది, మూలాధారం వలె అదే పరిమాణంతో లక్ష్యం అనే కొత్త పూర్ణాంక శ్రేణిని సృష్టిస్తుంది, ఆపై మూలకాలను మూలం నుండి లక్ష్యానికి కాపీ చేస్తుంది.
C#లో ద్విమితీయ పూర్ణాంక శ్రేణిని ప్రారంభించడానికి Array.Copy యొక్క వినియోగాన్ని ప్రదర్శించే ఉదాహరణను ప్రదర్శించడానికి నన్ను అనుమతించండి:
int [ , ] sourceArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;int [ , ] destinationArray = కొత్త int [ 3 , 2 ] ;
అర్రే.కాపీ ( sourceArray, destinationArray, sourceArray.Length ) ;
ఈ ఉదాహరణలో, మనకు 2-డైమెన్షనల్ పూర్ణాంక శ్రేణి అని పిలువబడుతుంది sourceAray 3 అడ్డు వరుసలు మరియు 2 నిలువు వరుసలతో. మేము ఉపయోగిస్తున్నాము అర్రే.కాపీ() sourceArray యొక్క కంటెంట్‌లను 3 అడ్డు వరుసలు మరియు 2 నిలువు వరుసలను కలిగి ఉన్న destinationArray అని పిలువబడే కొత్త 2-డైమెన్షనల్ పూర్ణాంక శ్రేణికి కాపీ చేయడానికి.
ది అర్రే.కాపీ() పద్ధతి పడుతుంది మూడు వాదనలు : ది మూల శ్రేణి , ది గమ్యం శ్రేణి , ఇంకా పొడవు కాపీ చేయవలసిన డేటా. ఈ సందర్భంలో, మేము మొత్తం కంటెంట్‌ను కాపీ చేస్తున్నాము sourceAray లోకి గమ్యంఅరే , కాబట్టి మేము పాస్ sourceAray.Length మూడవ వాదనగా.
మీరు ఉపయోగించవచ్చని గమనించండి అర్రే.కాపీ() మూలం మరియు గమ్యం శ్రేణులు ఒకే సంఖ్యలో కొలతలు మరియు ప్రతి పరిమాణంలో ఒకే పరిమాణాన్ని కలిగి ఉన్నంత వరకు, ఎన్ని కొలతలు కలిగిన శ్రేణులను ప్రారంభించేందుకు.
అలాగే, గుర్తుంచుకోండి అర్రే.కాపీ() మూలాధార శ్రేణి యొక్క నిస్సార కాపీని నిర్వహిస్తుంది, అంటే మూలం శ్రేణిలో సూచన రకాలు ఉంటే, సూచనలు కాపీ చేయబడతాయి కానీ ఆబ్జెక్ట్‌లు నకిలీ చేయబడవు.
ఉపయోగించే పూర్తి కోడ్ ఇక్కడ ఉంది అర్రే.కాపీ() C#లో శ్రేణిని ప్రారంభించే ఫంక్షన్:
వ్యవస్థను ఉపయోగించడం;తరగతి శ్రేణి
{
స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ )
{
// ప్రారంభించడం a 1 -dimensional array ఉపయోగించి Array.Copy
int [ ] sourceArray1D = { 1 , 2 , 3 , 4 , 5 } ;
int [ ] destinationArray1D = కొత్త int [ 5 ] ;
అర్రే.కాపీ ( sourceArray1D, destinationArray1D, sourceArray1D.పొడవు ) ;
కన్సోల్.WriteLine ( 'destinationArray1Dలో విలువలు:' ) ;
కోసం ( int i = 0 ; i < destinationArray1D.Length; i++ ) {
కన్సోల్.WriteLine ( గమ్యంఅరే1D [ i ] ) ;
}
// ప్రారంభించడం a 2 -dimensional array ఉపయోగించి Array.Copy
int [ , ] sourceArray2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
int [ , ] destinationArray2D = కొత్త int [ 3 , 2 ] ;
అర్రే.కాపీ ( sourceArray2D, destinationArray2D, sourceArray2D.పొడవు ) ;
కన్సోల్.WriteLine ( 'destinationArray2Dలో విలువలు:' ) ;
కోసం ( int i = 0 ; i < destinationArray2D.GetLength ( 0 ) ; i++ ) {
కోసం ( int j = 0 ; జె < destinationArray2D.GetLength ( 1 ) ; j++ ) {
కన్సోల్.WriteLine ( '({0}, {1}): {2}' , i, j, destinationArray2D [ i, j ] ) ;
}
}
}
}
ఈ కోడ్‌లో, మేము ఉపయోగిస్తున్నాము అర్రే.కాపీ() sourceArray1D అనే మూల శ్రేణి నుండి 1, 2, 3, 4 మరియు 5 విలువలతో destinationArray1D అని పిలువబడే 1-డైమెన్షనల్ పూర్ణాంక శ్రేణిని ప్రారంభించడం.
మేము కూడా ఉపయోగిస్తున్నాము అర్రే.కాపీ() sourceArray2D అనే మూల శ్రేణి నుండి {1, 2}, {3, 4} మరియు {5, 6} విలువలతో destinationArray2D అని పిలువబడే 2-డైమెన్షనల్ పూర్ణాంక శ్రేణిని ప్రారంభించడం.
మేము ప్రతి శ్రేణిలోని ప్రతి మూలకం ద్వారా మళ్ళించడానికి మరియు దాని విలువను కన్సోల్‌కు ప్రింట్ చేయడానికి లూప్‌ల కోసం అదనపు ఉపయోగిస్తాము.
ముగింపు
ఈ వ్యాసంలో, మేము C#లో శ్రేణులను ప్రారంభించే వివిధ మార్గాలను అన్వేషించాము. మేము కొత్త కీవర్డ్‌ని ఉపయోగించి, లూప్‌లను ఉపయోగించి శ్రేణులను ప్రారంభించడం మరియు Array.Copy() పద్ధతిని ఉపయోగించి అర్రే ఇనిషియలైజర్ సింటాక్స్‌ను కవర్ చేసాము. నిర్దిష్ట ఉపయోగ కేసుపై ఆధారపడి, ఈ పద్ధతుల్లో ప్రతి దాని స్వంత ప్రయోజనాలు మరియు అప్రయోజనాలు ఉన్నాయి. ఈ విభిన్న విధానాలతో మిమ్మల్ని మీరు పరిచయం చేసుకోవడం వలన మీ ప్రత్యేక అవసరాలకు అత్యంత అనుకూలమైనదాన్ని ఎంచుకోగలుగుతారు.