Nyilatkozat:
A tömbök deklarálása a „type[] ArrayName;” használatával történik. szintaxis, ahol a típus a tömbgyűjtemény tagjainak típusát jelöli, az „ArrName” pedig a tömbhöz rendelt cím. Egy tömb deklarációját szögletes zárójelek [] jelölik.
típus [ ] ArrayName = új típusú [ ] ; A listák a „List
Lista < típus > lista név = új lista < típus > ( ) ;
Inicializálás:
A tömbök kapcsos zárójeleket {} használnak az értékek közé, míg a listák az új List
típus [ ] ArrayName = { v1 , v2 , v3 , ... } ;
Lista < típus > lista név = új lista < típus > { v1 , v2 , v3 , ... } ;
Értékek hozzáadása:
Fontos megjegyezni, hogy a C# tömbök meghatározott mérettel rendelkeznek. Ha más méretre van szükség, akkor új „newArr” tömböt kell létrehozni a kívánt mérettel (jelenlegi hossz + új értékek száma). Adja hozzá az eredeti „OrgArr” tömböt az új tömbhöz, és rendelje hozzá az új értékeket az új tömb új pozícióihoz, és frissítse a hivatkozást az új tömbre.
Sor. Másolat ( OrgArr , újÉrk , OrgArr. Hossz ) ;
újÉrk [ OrgArr. Hossz ] = 14 ; // új érték
újÉrk [ OrgArr. Hossz + 1 ] = 2 ; // új érték
OrgArr = újÉrk ; // A hivatkozás frissítése int[] NewArr = new int[OrgArr.Length + 2];
A listák rugalmasságot kínálnak a méretkezelés tekintetében. Amikor egy lista inicializálva van, az egy kezdeti kapacitással kezdődik, de automatikusan kibővülhet, ha további elemeket adnak hozzá. Ez a dinamikus átméretezési képesség lehetővé teszi, hogy a listák alkalmazkodjanak a változó követelményekhez. A C# listák egy Add() függvényt biztosítanak az értékek hozzáadásához a listához. A következőképpen adhat hozzá értékeket egy C# listához:
Tömbök vs listák : Használati összehasonlítás a C-ben #
Hozzáférés az értékekhez
A tömbszámokban szereplő értékek a [] indexjelöléssel érhetők el, azaz a zárójelben lévő indexszám használatával, és egy másik változóba kerülnek mentésre.
típusú elem = ArrayName [ index ] ;A C#-lista értékeinek eléréséhez használhatja a [] indexjelölést a kívánt indexpozícióval együtt, hasonlóan a tömbökhöz.
típusú elem = Lista név [ index ] ;
Az értékek eltávolítása
A tömbök meghatározott hosszúságúak. Ezért az elemek eltávolításához új, kisebb méretű tömböt kell létrehozni, és a meglévő elemeket át kell másolni. Ezt megteheti az Array.Copy() függvény használatával, az „Értékek hozzáadása” részben leírtak szerint. A C# listákban az értékek eltávolítása sokkal egyszerűbb és intuitívabb. A List
Számold meg az értékeket
A C# tömbben lévő értékek megszámlálásához használhatja a tömb hossza attribútumot. A hossz tulajdonság megadja a tömbben lévő értékek teljes számát.
int számol = arrayName. Hossz ;A C# listában lévő értékek megszámlálásához használhatja a lista „számlálás” funkcióját. A listában jelenleg található elemek teljes mennyiségét szintén a „count” attribútum adja vissza.
int számol = lista név. Számol ;Ismételje meg az értékeket
Ha egy C# tömbben át szeretne iterálni az értékeket, használhat egy „for” ciklust a tömb hosszával a ciklusfeltételként.
számára ( int én = 0 ; én < ArrayName. Hossz ; én ++ ) {típus e = arrayName [ én ] ;
Konzol. WriteLine ( Ez ) ;
}
A C# lista értékei feletti iterációhoz használhat egy „foreach” ciklust, amely leegyszerűsíti az iterációs folyamatot azáltal, hogy automatikusan iterálja az elemeket.
az egyes ( írja be az e-t a listName mezőbe ) {Konzol. WriteLine ( Ez ) ;
}
1. példa: C# tömbök
A megadott kód deklarál és inicializál egy „Arr” nevű egész szám tömböt, amelynek hosszúsága 5, és értékeit rendeli az elemeihez. A tömbelemekhez rendelt értékek: 11, 12, 13, 14 és 15. A kód ezután a tömb elemeinek megjelenítésével folytatja a „for” ciklust. Minden összetevő külön sorban jelenik meg a Console.WriteLine() metódussal.
Az eredeti elemek megjelenítése után a kód módosítja a 2. indexű elemet egy új 10-es értékkel. Ezután a kód megjeleníti a módosított tömböt úgy, hogy ismét iterál az elemeken egy „for” ciklus segítségével. Végül a kód megjeleníti a tömbben található értékek teljes számát az „Arr.Length” tulajdonság használatával, amely megadja a tömb hosszát.
rendszer segítségével ;osztályú Dummy {
statikus üres Fő ( ) {
int [ ] Arr = új int [ 5 ] { tizenegy , 12 , 13 , 14 , tizenöt } ;
Konzol. WriteLine ( 'Elemek:' ) ;
számára ( int én = 0 ; én < Arr. Hossz ; én ++ )
{
Konzol. WriteLine ( Arr [ én ] ) ;
}
Arr [ 2 ] = 10 ;
Konzol. WriteLine ( 'Módosított tömb:' ) ;
számára ( int én = 0 ; én < Arr. Hossz ; én ++ )
{
Konzol. WriteLine ( Arr [ én ] ) ;
}
Konzol. WriteLine ( 'Elemek száma: ' + Arr. Hossz ) ;
}
}
2. példa: C# listák
Az alábbi kód bemutatja a C# lista használatát egész számok gyűjteményének tárolására és kezelésére. Először is, a kód inicializál egy „Arr” nevű listát öt egész számmal: 11, 12, 13, 14 és 15. Ezt a List
Ezután a program kinyomtatja az „Elements:” üzenetet, és folytatja a lista minden elemének iterációját egy „foreach” ciklus segítségével. Minden iteráció során az aktuális elem a Console.WriteLine() metódussal kerül kinyomtatásra a konzolra.
Ezt követően a kód módosítja a lista 2. indexénél lévő értéket úgy, hogy 10-et rendel hozzá (Arr[2] = 10). Ez a sor a lista harmadik elemét 13-ról 10-re módosítja. A módosítást követően a program ismét kiírja a „Módosított lista:” üzenetet, és a frissített listán ismétlődik, minden elemet kinyomtatva a konzolra. A kód ezután megjeleníti a listában szereplő értékek számát az „Arr.Count” használatával. Ez a tulajdonság a listában szereplő elemek számát adja vissza, amely a következő forgatókönyv szerint 5.
Végül a kód eltávolítja a listából a 4 értékű elemet az Arr.Remove(4) metódussal. Ez a módszer megkeresi a megadott értéket a listában, és eltávolítja annak első előfordulását. Végül a program kinyomtatja a „Lista eltávolítás után:” üzenetet, és ismét végigfut a listán, megjelenítve az eltávolítási művelet után az összes megmaradt elemet.
rendszer segítségével ;rendszer segítségével. Gyűjtemények . Generikus ;
osztályú Dummy {
statikus üres Fő ( ) {
Lista < int > Arr = új lista < int > ( ) { tizenegy , 12 , 13 , 14 , tizenöt } ;
Konzol. WriteLine ( 'Elemek:' ) ;
az egyes ( int n in Arr )
{
Konzol. WriteLine ( n ) ;
}
Arr [ 2 ] = 10 ;
Konzol. WriteLine ( 'Módosított lista:' ) ;
az egyes ( int n in Arr )
{
Konzol. WriteLine ( n ) ;
}
Konzol. WriteLine ( 'Elemek száma: ' + Arr. Számol ) ;
Arr. Távolítsa el ( 4 ) ;
Konzol. WriteLine ( 'Lista eltávolítás után:' ) ;
az egyes ( int n in Arr )
{
Konzol. WriteLine ( n ) ;
}
}
}
Következtetés
Ez az útmutató a C# tömbök és a C# listák közötti alapvető szintaktikai különbségeket tárgyalta. A tömbök fix hosszúságúak, és indexen keresztül érhetők el, míg a listák dinamikus méretűek, és további módszereket biztosítanak az elemek hozzáadásához és eltávolításához. Emellett rendelkezésre bocsátottuk a C# listás programokat, amelyek bemutatják a deklarációt, az inicializálást, a hozzáférést, a módosítást, a számlálást és az elemek hozzáadását.