Verklaring:
Arrays worden gedeclareerd met behulp van de opdracht “type[] ArrayName;” syntaxis waarbij het type het type leden in de arraycollectie aangeeft, en “ArrName” de titel is die aan de array is toegewezen. Een declaratie van een array wordt aangegeven met vierkante haken [].
type [ ] Arraynaam = nieuw type [ ] ; Lijsten worden gedeclareerd met behulp van de opdracht “List
Lijst < type > Lijstnaam = nieuwe lijst < type > ( ) ;
Initialisatie:
Arrays gebruiken accolades {} om de waarden te omsluiten, terwijl lijsten de nieuwe List
type [ ] Arraynaam = { v1 , v2 , v3 , ... } ;
Lijst < type > Lijstnaam = nieuwe lijst < type > { v1 , v2 , v3 , ... } ;
Waarden toevoegen:
Het is cruciaal om te onthouden dat de C#-arrays een specifieke grootte hebben. Als een andere grootte vereist is, moet een nieuwe array “newArr” worden aangemaakt met de gewenste grootte (huidige lengte + aantal nieuwe waarden). Voeg de originele array “OrgArr” toe aan de nieuwe array en wijs de nieuwe waarden toe aan de nieuwe posities in de nieuwe array en werk de verwijzing bij naar de nieuwe array.
Array. Kopiëren ( OrgArr , nieuwArr , OrgArr. Lengte ) ;
nieuwArr [ OrgArr. Lengte ] = 14 ; // nieuwe waarde
nieuwArr [ OrgArr. Lengte + 1 ] = 2 ; // nieuwe waarde
OrgArr = nieuwArr ; // Update de referentie int[] NewArr = new int[OrgArr.Length + 2];
Lijsten bieden flexibiliteit op het gebied van omvangbeheer. Wanneer een lijst wordt geïnitialiseerd, begint deze met een initiële capaciteit, maar deze kan automatisch worden uitgebreid naarmate er meer elementen worden toegevoegd. Dankzij deze dynamische mogelijkheid om de grootte aan te passen, kunnen de lijsten zich aanpassen aan veranderende vereisten. De C#-lijsten bieden een Add()-functie om de waarden aan de lijst toe te voegen. Zo kunt u waarden toevoegen aan een C#-lijst:
Arrays versus lijsten : Gebruiksvergelijking in C #
Toegang tot de waarden
De waarden in de arraynummers zijn toegankelijk met behulp van de indexnotatie [], d.w.z. met behulp van het indexnummer tussen haakjes, en worden opgeslagen in een andere variabele.
type-element = Arraynaam [ inhoudsopgave ] ;Om toegang te krijgen tot de waarden in een C#-lijst, kunt u ook de indexnotatie [] gebruiken samen met de gewenste indexpositie, vergelijkbaar met arrays.
type-element = Lijstnaam [ inhoudsopgave ] ;
De waarden verwijderen
Arrays hebben een vaste lengte. Om de elementen te verwijderen, moet er daarom een nieuwe array worden gemaakt met een kleinere omvang, en moeten de bestaande elementen worden gekopieerd. Dit kan worden gedaan door de functie Array.Copy() te gebruiken, zoals uitgelegd in de sectie “Waarden toevoegen”. In C#-lijsten is het verwijderen van de waarden veel eenvoudiger en intuïtiever. De klasse List
Tel de waarden
Om de waarden in een C#-array te tellen, kunt u het lengte-attribuut van de array gebruiken. De eigenschap length geeft u het totale aantal waarden in de array.
int graaf = arraynaam. Lengte ;Om de waarden in een C#-lijst te tellen, kunt u de ‘tel’-functie van de lijst gebruiken. Het totale aantal elementen dat zich momenteel in de lijst bevindt, wordt eveneens geretourneerd door het attribuut “count”.
int graaf = Lijstnaam. Graaf ;Herhaal de waarden
Om waarden in een C#-array te herhalen, kunt u een “for”-lus gebruiken met de lengte van de array als lusvoorwaarde.
voor ( int i = 0 ; i < Arraynaam. Lengte ; i ++ ) {typ e = arraynaam [ i ] ;
Troosten. Schrijf lijn ( Het is ) ;
}
Om de waarden in een C#-lijst te herhalen, kunt u een “foreach”-lus gebruiken, omdat deze het iteratieproces vereenvoudigt door automatisch de elementen te herhalen.
voorleggen ( typ e in lijstnaam ) {Troosten. Schrijf lijn ( Het is ) ;
}
Voorbeeld 1: C#-arrays
De gegeven code declareert en initialiseert een integer-array met de naam “Arr” met een lengte van 5 en wijst de waarden toe aan de elementen ervan. De toegewezen waarden aan de array-elementen zijn 11, 12, 13, 14 en 15. De code gaat vervolgens verder met het weergeven van de elementen van de array met behulp van een “for”-lus. Elke component wordt op een afzonderlijke regel weergegeven met behulp van de Console.WriteLine() -methode.
Nadat de originele elementen zijn weergegeven, wijzigt de code het element op index 2 door er een nieuwe waarde van 10 aan toe te kennen. Vervolgens geeft de code de gewijzigde array weer door de elementen opnieuw te doorlopen met behulp van een “for”-lus. Ten slotte geeft de code het totale aantal waarden weer dat zich in de array bevindt met behulp van de eigenschap 'Arr.Length', die de lengte van de array oplevert.
met behulp van Systeem ;klasse Dummie {
statisch leegte Voornaamst ( ) {
int [ ] Arr = nieuw int [ 5 ] { elf , 12 , 13 , 14 , vijftien } ;
Troosten. Schrijf lijn ( 'Elementen:' ) ;
voor ( int i = 0 ; i < Arr. Lengte ; i ++ )
{
Troosten. Schrijf lijn ( Arr [ i ] ) ;
}
Arr [ 2 ] = 10 ;
Troosten. Schrijf lijn ( 'Gewijzigde array:' ) ;
voor ( int i = 0 ; i < Arr. Lengte ; i ++ )
{
Troosten. Schrijf lijn ( Arr [ i ] ) ;
}
Troosten. Schrijf lijn ( 'Aantal elementen: ' + Arr. Lengte ) ;
}
}
Voorbeeld 2: C#-lijsten
De volgende meegeleverde code demonstreert het gebruik van een C#-lijst voor het opslaan en manipuleren van een verzameling gehele getallen. Eerst initialiseert de code een lijst met de naam “Arr” met vijf gehele getallen: 11, 12, 13, 14 en 15. Dit wordt bereikt met behulp van de klasse List
Vervolgens drukt het programma het bericht “Elements:” af en gaat het verder met het herhalen van elk element in de lijst met behulp van een “foreach”-lus. Tijdens elke iteratie wordt het huidige element naar de console afgedrukt met behulp van de Console.WriteLine() -methode.
Daarna wijzigt de code de waarde op index 2 van de lijst door hieraan de waarde 10 toe te kennen (Arr[2] = 10). Deze regel verandert het derde element in de lijst van 13 in 10. Na de wijziging drukt het programma opnieuw het bericht 'Gewijzigde lijst:' af en herhaalt het de bijgewerkte lijst, waarbij elk element naar de console wordt afgedrukt. De code geeft vervolgens het aantal waarden in de lijst weer met behulp van 'Arr.Count'. Deze eigenschap retourneert het aantal items dat aanwezig is in de lijst, wat in het volgende scenario 5 is.
Ten slotte verwijdert de code het element met de waarde 4 uit de lijst met behulp van de methode Arr.Remove(4). Deze methode zoekt naar de opgegeven waarde in de lijst en verwijdert de eerste keer dat deze voorkomt. Ten slotte drukt het programma het bericht “Lijst na verwijdering:” af en herhaalt de lijst nogmaals, waarbij elk overblijvend element na de verwijdering wordt weergegeven.
met behulp van Systeem ;met behulp van Systeem. Collecties . Algemeen ;
klasse Dummie {
statisch leegte Voornaamst ( ) {
Lijst < int > Arr = nieuwe lijst < int > ( ) { elf , 12 , 13 , 14 , vijftien } ;
Troosten. Schrijf lijn ( 'Elementen:' ) ;
voorleggen ( int n in Arr )
{
Troosten. Schrijf lijn ( N ) ;
}
Arr [ 2 ] = 10 ;
Troosten. Schrijf lijn ( 'Gewijzigde lijst:' ) ;
voorleggen ( int n in Arr )
{
Troosten. Schrijf lijn ( N ) ;
}
Troosten. Schrijf lijn ( 'Aantal elementen: ' + Arr. Graaf ) ;
Arr. Verwijderen ( 4 ) ;
Troosten. Schrijf lijn ( 'Lijst na verwijdering:' ) ;
voorleggen ( int n in Arr )
{
Troosten. Schrijf lijn ( N ) ;
}
}
}
Conclusie
In deze handleiding worden de fundamentele syntaxisverschillen tussen de C#-arrays en C#-lijsten behandeld. De arrays hebben een vaste lengte en zijn toegankelijk via index, terwijl de lijsten een dynamische grootte hebben en aanvullende methoden bieden om de elementen toe te voegen en te verwijderen. Daarnaast hebben we de C#-lijstprogramma's geleverd die de elementen declareren, initialiseren, openen, wijzigen, tellen en toevoegen.