Lists

Een List in Dart is een geordende collectie die elementen van elk type kan bevatten, zoals getallen, strings, en zelfs andere lijsten. Deze flexibiliteit maakt lijsten een van de meest gebruikte datastructuren in Dart.

Definiëren van List variabelen

Je kunt een List definiëren door het type List te specificeren gevolgd door het type van de elementen die het bevat tussen hoekige haakjes (generieke typeaanduiding). Daarna volgt de lijst van elementen tussen vierkante haken.

Voorbeelden:

void main() {
  List<int> getallen = [1, 2, 3, 4, 5]; // lijst van gehele getallen
  List<String> namen = ['Alice', 'Bob', 'Charlie']; // lijst van strings
  List<double> legeLijst = []; // een lege lijst voor double waarden
  List<dynamic> diverseElementen = [1, 'two', 3.0, [4, 5]]; // lijst met gemengde types inclusief een andere lijst

  print(getallen);
  print(namen);
  print(legeLijst);
  print(diverseElementen); // Output: [1, 'two', 3.0, [4, 5]]
}

Toegang krijgen tot elementen in een List

Toegang tot de elementen van een lijst kan via de index van het element, waarbij de indexering start bij 0.

void main() {
  List<String> namen = ['Alice', 'Bob', 'Charlie'];
  print(namen[0]); // Output: Alice
  print(namen[1]); // Output: Bob
  print(namen[2]); // Output: Charlie
}

Wijzigen van elementen in een List

Je kunt de waarde van een element wijzigen door de index van het element te gebruiken.

void main() {
  List<int> getallen = [1, 2, 3, 4, 5];
  getallen[2] = 10; // Wijzig het derde element
  print(getallen); // Output: [1, 2, 10, 4, 5]
}

Lijstmethoden en -eigenschappen

Dart biedt een reeks methoden voor het manipuleren van lijsten. Hier zijn enkele van de meest gebruikte methoden:

Elementen toevoegen en verwijderen:

void main() {
  List<int> getallen = [1, 2, 3];
  getallen.add(4); // Voeg een element toe aan het einde
  getallen.addAll([5, 6]); // Voeg meerdere elementen toe
  getallen.remove(2); // Verwijder een element met waarde 2
  getallen.removeAt(0); // Verwijder het element op index 0
  print(getallen); // Output: [3, 4, 5, 6]
}

Elementen zoeken en lijsteigenschappen:

void main() {
  List<int> getallen = [1, 2, 3, 4, 5];
  bool bevatDrie = getallen.contains(3); // Controleren of een element bestaat
  int lengte = getallen.length; // Verkrijg de lengte van de lijst
  print(bevatDrie); // Output: true
  print(lengte); // Output: 5
}

Sorteren en omkeren:

void main() {
  List<int> getallen = [5, 3, 1, 4, 2];
  getallen.sort(); // Sorteer de lijst
  print(getallen); // Output: [1, 2, 3, 4, 5]
  getallen.reverse(); // Keer de volgorde van de lijst om
  print(getallen); // Output: [5, 4, 3, 2, 1]
}

Deze uitgebreidere informatie over het werken met lijsten in Dart biedt een gedetailleerd beeld van hoe je lijsten effectief kunt gebruiken en manipuleren voor verschillende programmeertaken.

Het itereren van een lijst

Het itereren (Iterate) over een lijst in Dart kan op verschillende manieren worden uitgevoerd, elk met hun eigen specifieke kenmerken en gebruikssituaties. Hieronder zal ik de drie meest voorkomende methoden voor het doorlopen van een List uitleggen en verduidelijken: de for-lus, de for-in-lus en de forEach-methode.

De for-lus

De traditionele for-lus is handig wanneer je meer controle nodig hebt over het indexeren van elementen, zoals wanneer je toegang wilt tot de index van elk element of wanneer je de lijst in stappen wilt doorlopen.

Voorbeeld:

void main() {
  List<String> namen = ['Alice', 'Bob', 'Charlie'];
  for (int i = 0; i < namen.length; i++) {
    print(namen[i]);  // Hier kun je ook de index i gebruiken voor andere doeleinden.
  }
}

De for-in-lus

De for-in-lus is een meer leesbare en beknopte manier om over een lijst te itereren wanneer je alleen geïnteresseerd bent in de waarden van de lijst en niet in de indices van de elementen. Dit is vooral handig als je de lijst slechts wilt doorlopen om elke waarde te gebruiken zonder dat je de positie van elk item in de lijst nodig hebt.

Voorbeeld:

void main() {
  List<String> namen = ['Alice', 'Bob', 'Charlie'];
  for (var naam in namen) {
    print(naam);  // Simpeler, geen directe toegang tot de index.
  }
}

3. De forEach-methode

De forEach-methode is een alternatieve, meer functionele manier om iteratie te benaderen, wat erg handig kan zijn, vooral wanneer je werkt met functies als argumenten. Het maakt de code vaak leesbaarder en korter, vooral bij het gebruik van arrow-functies. Het nadeel is dat je niet direct de lus kunt onderbreken of voortijdig kunt verlaten, wat met een for– of for-in-lus wel mogelijk is.

Voorbeeld:

void main() {
  List<String> namen = ['Alice', 'Bob', 'Charlie'];
  namen.forEach((naam) => print(naam));  // Directe, functionele stijl van itereren.
}

Samenvatting van de Verschillen

• Controle over indices: Gebruik de for-lus als je toegang nodig hebt tot de index van elk element tijdens de iteratie.
• Leesbaarheid en eenvoud: Kies de for-in-lus voor de meest directe en leesbare manier om door elementen te lopen zonder dat je de index nodig hebt.
• Functionele benadering: Opteer voor de forEach-methode wanneer je een meer functionele programmeerstijl wilt en wanneer de code kort en expressief moet zijn.

Methodes

add(E value): Voegt een element toe aan de lijst.

List numbers = [1, 2, 3];
numbers.add(4); // [1, 2, 3, 4]

addAll(Iterable<E> iterable): Voegt meerdere elementen toe aan het einde van de lijst.

getallen.addAll([5, 6]);  // De lijst wordt nu [1, 2, 3, 4, 5, 6]

remove(Object value): Verwijdert het eerste voorkomen van het element in de lijst.

List<int> numbers = [1, 2, 3, 2];
numbers.remove(2); // [1, 3, 2]

removeAt(int index): Verwijdert het element op de gespecificeerde index.

getallen.removeAt(0);  // Verwijdert het eerste element, lijst wordt [3, 4, 5, 6]

contains(Object element): Controleert of de lijst het element bevat.

List<int> numbers = [1, 2, 3];
bool hasTwo = numbers.contains(2); // true

length: Geeft de lengte van de lijst.

List<int> numbers = [1, 2, 3];
int len = numbers.length; // 3

isEmpty en isNotEmpty: Controleert of de lijst leeg is of niet.

List<int> numbers = [];
bool empty = numbers.isEmpty; // true

map<T>(T Function(E e)): Past een functie toe op elk element in de lijst en retourneert een iterable.

List<int> numbers = [1, 2, 3];
List<int> squared = numbers.map((n) => n * n).toList(); // [1, 4, 9] Kwadrateert elk element

• sort(): Sorteert de lijst in oplopende volgorde.

getallen.sort();

• reverse(): Keert de volgorde van de elementen in de lijst om.

List<int> omgekeerd = getallen.reversed.toList();