Comment créer une liste dans Dart

List  nom_de_la_liste = [<éléments de la liste>]
// afficher la liste
print( nom_de_la_liste);
// Utiliser le clé var
var nomDeLaListe = [1, 2, 3, 4, 5];
// afficher la liste
print(nomDeLaListe);

List<int> myList = [1, 2, 3, 4, 5]; // Crée une liste d'entiers
 // afficher la liste
print(myList);
List<String> fruits = ['pomme', 'banane', 'orange']; // Crée une liste de chaînes de caractères
// afficher la liste
print(fruits);

void main(){
// définir une liste du type String
List  maListe = ["Laptop" , "télévision" , "Phone"];
// afficher la liste
print(maListe);
}

1. Utilisation de l’opérateur d’index ([]):

• Vous pouvez accéder à un élément spécifique d’une liste en utilisant l’opérateur d’index, qui ressemble à ceci :

var maListe = [1, 2, 3, 4, 5];
var premierElement = maListe[0]; // Accéder au premier élément (1)
var deuxiemeElement = maListe[1]; // Accéder au deuxième élément (2)

• Dans cet exemple, maListe[0] renvoie le premier élément de la liste maListe, et maListe[1] renvoie le deuxième élément.
• Exemple

void main(){
// définir une liste du type String
//on peut dans ce cas insérer différents types de variables
List maListe = ["Dart" , "Python" , "Java"];
// afficher le premier élément (index 0) de la liste
print(maListe[0]); // affiche Dart
}

2. Utilisation de la méthode elementAt() :

• Dart propose également une méthode elementAt() que vous pouvez utiliser pour accéder à un élément d’une liste en spécifiant l’index de l’élément souhaité. Voici comment vous pouvez l’utiliser :

var maListe = [1, 2, 3, 4, 5];
var troisiemeElement = maListe.elementAt(2); // Accéder au troisième élément (3)
var cinquiemeElement = maListe.elementAt(4); // Accéder au cinquième élément (5)

• La méthode elementAt() prend un index en argument et renvoie l’élément correspondant de la liste.

3. Utilisation de la boucle for :

• On peut aussi parcourir les éléments d’une liste Dart à l’aide de la boucle for

void main(){
  var l = [11,27,13 ,9]; 
  for (var  x in l){
    print(x);
  } 
}

Utilisez la méthode qui vous convient le mieux en fonction de votre besoin spécifique. L’opérateur d'index est plus couramment utilisé pour un accès direct aux éléments de la liste, tandis que la méthode elementAt() peut être utile dans certaines situations où vous devez accéder à un élément en fonction d’une logique plus complexe.

La boucle for est un moyen efficace de parcourir et d’accéder aux éléments d’une liste en Dart, en plus des méthodes mentionnées précédemment, comme l’opérateur d’index ([]) et la méthode elementAt().

List fixedList = List(3); // Crée une liste à longueur fixe de taille 3

void main() {
  // declaration of fixed length list
  var fixedList = new List.filled(5, 0, growable: false);
  // inserting values in the fixed length list
  fixedList[0] = 1;
  fixedList[1] = 2;
  fixedList[2] = 3;
  fixedList[3] = 4;
  fixedList[4] = 5;
  // fixedList[ 5 ] = 6; Including this line throws an error
  // printing elements of the fixed length list
  print(' \n Elements in the list are as follows: $fixedList ');
}

List growableList = [1, 2, 3]; // Crée une liste extensible

void main( )
{
  // declaring growable list
  var growableList = new List< int >.filled( 0, 0, growable: true );
  // initializing growable list with values
  growableList = [ 0, 1, 2, 3, 4, 5 ];
  print( ' The elements in the growable list are : $growableList ' );
  // adding element 6 to the growable list
  growableList.add( 6 );
  print( ' After adding 6 to the list, he elements in the growable list are : $growableList ' );
}

1. Exercice 1 : Somme des éléments d'une liste

• Écrivez un programme Dart qui utilise la méthode forEach pour calculer la somme des éléments d'une liste de nombres et affiche le résultat.

void main() {
  List nombres = [1, 2, 3, 4, 5];
  int somme = 0;

  nombres.forEach((nombre) {
    somme += nombre;
  });

  print("La somme des éléments de la liste est : $somme");
}

2. Exercice 2 : Afficher la longueur de chaque mot dans une liste de chaînes

• Écrivez un programme Dart qui utilise forEach pour parcourir une liste de mots et affiche la longueur de chaque mot.

void main() {
  List mots = ["chat", "chien", "oiseau", "éléphant", "tortue"];

  mots.forEach((mot) {
    print("Le mot '$mot' a une longueur de ${mot.length} caractères.");
  });
}

3. Exercice 3 : Filtrer les nombres pairs d'une liste

• Écrivez un programme Dart qui utilise forEach pour parcourir une liste de nombres et affiche uniquement les nombres pairs.

void main() {
  List nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

  print("Nombres pairs :");
  nombres.forEach((nombre) {
    if (nombre % 2 == 0) {
      print(nombre);
    }
  });
}

4. Exercice 4 : Affichage des éléments d'une liste

• Écrivez un programme qui utilise la méthode forEach pour parcourir une liste de noms et les affiche un par un.

void main() {
  List noms = ['Alice', 'Bob', 'Charlie', 'David', 'Eve'];
  noms.forEach((nom) {
    print(nom);
  });
}

5. Exercice 5 : Recherche de la valeur maximale

• Écrivez un programme qui utilise forEach pour trouver la valeur maximale dans une liste de nombres.

void main() {
  List nombres = [7, 3, 9, 2, 11, 5];
  int max = nombres[0]; // Initialise max avec le premier élément de la liste
  nombres.forEach((nombre) {
    if (nombre > max) {
      max = nombre;
    }
  });
  print("La valeur maximale est : $max");
}

• Ces exercices devraient vous aider à vous familiariser avec l'utilisation de forEach pour parcourir et effectuer des opérations sur les éléments d'une liste en Dart.

• Enoncé

• Écrivez une fonction nommée calculateSum qui prend en entrée une liste d'entiers et retourne la somme de tous ses éléments. Ensuite, dans la fonction main, créez une liste d'entiers de votre choix, appelez la fonction calculateSum avec cette liste et affichez le résultat.
Solution

void main() {
  List numbers = [1, 2, 3, 4, 5];

  // Appel de la fonction pour calculer la somme des éléments de la liste
  int sum = calculateSum(numbers);

  // Affichage du résultat
  print("La somme des éléments de la liste est : $sum");
}

int calculateSum(List numbers) {
  int sum = 0;

  // Parcours de chaque élément de la liste et ajout à la somme
  for (int number in numbers) {
    sum += number;
  }

  return sum;
}

• Écrivez une fonction nommée searchElement qui prend en entrée une liste d'entiers et un entier à rechercher, et retourne un booléen indiquant si l'élément est présent dans la liste ou non.
• Ensuite, dans la fonction main, créez une liste d'entiers de votre choix et demandez à l'utilisateur de saisir un nombre. Appelez ensuite la fonction searchElement avec la liste et le nombre saisi par l'utilisateur, puis affichez si l'élément est présent dans la liste ou non.
• Voici un exemple de code vide pour commencer :

import 'dart:io';

// Écrivez votre fonction searchElement ici

void main() {
  List numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; // Vous pouvez changer cette liste selon vos besoins

  stdout.write("Entrez un nombre à rechercher dans la liste : ");
  int target = int.parse(stdin.readLineSync()!); // Saisie de l'utilisateur

  // Appelez la fonction searchElement avec la liste numbers et le nombre saisi par l'utilisateur,
  // puis affichez si l'élément est présent dans la liste ou non
  
}

• Remplir la fonction searchElement pour qu'elle recherche correctement l'élément dans la liste et retourne true s'il est présent et false sinon. Une fois qu'ils auront terminé, ils pourront exécuter le programme pour vérifier si leur fonction fonctionne comme prévu.