Declaraţie:
Matricele sunt declarate folosind „type[] ArrayName;” sintaxă în care tipul semnifică tipul membrilor din colecția de matrice, iar „ArrName” este titlul care este atribuit matricei. O declarație a unui tablou este notată prin paranteze drepte [].
tip [ ] ArrayName = tip nou [ ] ; Listele sunt declarate folosind „List
Listă < tip > listName = Listă nouă < tip > ( ) ;
Inițializare:
Matricele folosesc acolade {} pentru a include valorile, în timp ce listele folosesc noul constructor List
tip [ ] ArrayName = { v1 , v2 , v3 , ... } ;
Listă < tip > listName = Listă nouă < tip > { v1 , v2 , v3 , ... } ;
Adăugarea de valori:
Este esențial să ne amintim că tablourile C# au o dimensiune specifică. Dacă este necesară o dimensiune diferită, trebuie creată o nouă matrice „newArr” cu dimensiunea dorită (lungimea curentă + numărul de valori noi). Adăugați matricea originală „OrgArr” la noua matrice și atribuiți noile valori noilor poziții din noua matrice și actualizați referința la noua matrice.
Matrice. Copie ( OrgArr , nouArr , OrgArr. Lungime ) ;
nouArr [ OrgArr. Lungime ] = 14 ; // valoare nouă
nouArr [ OrgArr. Lungime + 1 ] = 2 ; // valoare nouă
OrgArr = nouArr ; // Actualizați referința int[] NewArr = new int[OrgArr.Length + 2];
Listele oferă flexibilitate în ceea ce privește gestionarea dimensiunii. Când o listă este inițializată, începe cu o capacitate inițială, dar se poate extinde automat pe măsură ce se adaugă mai multe elemente. Această capacitate de redimensionare dinamică permite listelor să se adapteze la cerințele în schimbare. Listele C# oferă o funcție Add() pentru a adăuga valorile listei. Iată cum puteți adăuga valori la o listă C#:
Matrice vs Liste : Comparație de utilizare în C #
Accesarea Valorilor
Valorile din numerele matricei sunt accesate folosind notația de index [], adică folosind numărul de index din paranteze și sunt salvate într-o altă variabilă.
element de tip = ArrayName [ index ] ;Pentru a accesa valorile dintr-o listă C#, puteți utiliza, de asemenea, notația de index [] împreună cu poziția de index dorită, similară matricelor.
element de tip = ListName [ index ] ;
Eliminarea Valorilor
Matricele au o lungime stabilită. Prin urmare, pentru a elimina elementele, trebuie creată o nouă matrice cu o dimensiune mai mică, iar elementele existente trebuie copiate. Acest lucru se poate face prin folosirea funcției Array.Copy() așa cum este explicat în secțiunea „Adăugarea de valori”. În listele C#, eliminarea valorilor este mult mai simplă și mai intuitivă. Clasa List
Numărați Valorile
Pentru a număra valorile dintr-o matrice C#, puteți folosi atributul lungime al matricei. Proprietatea length vă oferă numărul total de valori din matrice.
int numara = arrayName. Lungime ;Pentru a număra valorile dintr-o listă C#, puteți folosi caracteristica „numărare” a listei. Cantitatea totală de elemente care se află în prezent în listă este, de asemenea, returnată de atributul „count”.
int numara = listName. Numara ;Repetați valorile
Pentru a repeta peste valori dintr-o matrice C#, puteți utiliza o buclă „for” cu lungimea matricei ca condiție de buclă.
pentru ( int i = 0 ; i < ArrayName. Lungime ; i ++ ) {tip e = arrayName [ i ] ;
Consolă. WriteLine ( Este ) ;
}
Pentru a repeta peste valorile dintr-o listă C#, puteți utiliza o buclă „foreach”, deoarece simplifică procesul de iterație prin iterarea automată peste elemente.
pentru fiecare ( tastați e în listName ) {Consolă. WriteLine ( Este ) ;
}
Exemplul 1: C# Arrays
Codul dat declară și inițializează un tablou întreg numit „Arr” cu o lungime de 5 și atribuie valorile elementelor sale. Valorile atribuite elementelor matricei sunt 11, 12, 13, 14 și 15. Codul continuă apoi să afișeze elementele matricei folosind o buclă „for”. Fiecare componentă este afișată pe o linie distinctă folosind metoda Console.WriteLine().
După afișarea elementelor originale, codul modifică elementul de la indexul 2 prin alocarea acestuia cu o nouă valoare de 10. În continuare, codul afișează matricea modificată prin iterarea elementelor din nou folosind o buclă „for”. În cele din urmă, codul afișează numărul total de valori care rezidă în matrice folosind proprietatea „Arr.Length” care dă lungimea matricei.
folosind System ;manechin de clasă {
static gol Principal ( ) {
int [ ] Arr = nou int [ 5 ] { unsprezece , 12 , 13 , 14 , cincisprezece } ;
Consolă. WriteLine ( 'Elemente:' ) ;
pentru ( int i = 0 ; i < Arr. Lungime ; i ++ )
{
Consolă. WriteLine ( Arr [ i ] ) ;
}
Arr [ 2 ] = 10 ;
Consolă. WriteLine ( „Matrice modificată:” ) ;
pentru ( int i = 0 ; i < Arr. Lungime ; i ++ )
{
Consolă. WriteLine ( Arr [ i ] ) ;
}
Consolă. WriteLine ( „Numărul de elemente:” + Arr. Lungime ) ;
}
}
Exemplul 2: Liste C#
Următorul cod furnizat demonstrează utilizarea unei liste C# pentru a stoca și manipula o colecție de numere întregi. În primul rând, codul inițializează o listă numită „Arr” cu cinci numere întregi: 11, 12, 13, 14 și 15. Acest lucru se realizează folosind clasa List
Apoi, programul tipărește mesajul „Elemente:” și continuă să itereze peste fiecare element din listă folosind o buclă „foreach”. În timpul fiecărei iterații, elementul curent este imprimat pe consolă folosind metoda Console.WriteLine().
Ulterior, codul modifică valoarea de la indexul 2 al listei, atribuindu-i valoarea 10 (Arr[2] = 10). Această linie schimbă al treilea element din listă de la 13 la 10. În urma modificării, programul imprimă din nou mesajul „Lista modificată:” și iterează peste lista actualizată, imprimând fiecare element pe consolă. Codul afișează apoi numărul de valori din listă folosind „Arr.Count”. Această proprietate returnează numărul de elemente care sunt prezente în listă care, în scenariul următor, se întâmplă să fie 5.
În cele din urmă, codul elimină elementul cu valoarea 4 din listă folosind metoda Arr.Remove(4). Această metodă caută valoarea specificată în listă și elimină prima apariție a acesteia. În cele din urmă, programul tipărește mesajul „List after removal:” și repetă din nou peste listă, afișând fiecare element rămas după operația de eliminare.
folosind System ;folosind System. Colecții . Generic ;
manechin de clasă {
static gol Principal ( ) {
Listă < int > Arr = Listă nouă < int > ( ) { unsprezece , 12 , 13 , 14 , cincisprezece } ;
Consolă. WriteLine ( 'Elemente:' ) ;
pentru fiecare ( int n în Arr )
{
Consolă. WriteLine ( n ) ;
}
Arr [ 2 ] = 10 ;
Consolă. WriteLine ( „Lista modificată:” ) ;
pentru fiecare ( int n în Arr )
{
Consolă. WriteLine ( n ) ;
}
Consolă. WriteLine ( „Numărul de elemente:” + Arr. Numara ) ;
Arr. Elimina ( 4 ) ;
Consolă. WriteLine ( „Lista după eliminare:” ) ;
pentru fiecare ( int n în Arr )
{
Consolă. WriteLine ( n ) ;
}
}
}
Concluzie
Acest ghid a acoperit diferențele de sintaxă de bază dintre tablourile C# și listele C#. Matricele au lungime fixă și sunt accesate prin index, în timp ce listele sunt dimensionate dinamic și oferă metode suplimentare de adăugare și eliminare a elementelor. Împreună cu aceasta, am furnizat programele de listă C# care prezintă declararea, inițializarea, accesarea, modificarea, numărarea și adăugarea elementelor.