Types de collections Dart

Une collection est une structure de données utilisée pour stocker plusieurs éléments de données.

Dart possède trois types de collections principaux intégrés : List, Set et Map. Ce chapitre présentera leur utilisation une par une.


List : liste ordonnée

List est le type de collection le plus couramment utilisé, servant à stocker un groupe ordonné d'éléments et autorisant les doublons.

Vous pouvez accéder à n'importe quel élément d'une List par son index (en commençant à 0).

Créer une List

Exemple

void main() {
  // Créer une List à l'aide de littéraux
  List<String> sites = ['EXAMPLE', 'Google', 'GitHub'];
  print(Liste des sites web : $sites);

  // Inférence de type (types génériques omis)
  var numbers = [1, 2, 3, 4, 5];
  print(Liste de nombres : $numbers);

  // Créer une liste vide
  var emptyList = <String>[];

  // Créer une liste de longueur fixe à l'aide de List.filled
  var zeros = List.filled(3, 0);  // [0, 0, 0]
  print(Liste remplie : $zeros);

  // Générer une liste avec List.generate
  var squares = List.generate(5, (i) => i * i);
  print(Liste de nombres carrés : $squares);
}
网站列表: [EXAMPLE, Google, GitHub]
数字列表: [1, 2, 3, 4, 5]
填充列表: [0, 0, 0]
平方数列表: [0, 1, 4, 9, 16]

Accès et modification des éléments de liste

Exemple

void main() {
  var fruits = [Pomme, Banane, Orange];

  // Accès par index (à partir de 0)
  print('Premier fruit : ${fruits[0]}');  // Pomme
  print('Dernier : ${fruits[fruits.length - 1]}');  // Orange

  // Modifier l'élément
  fruits[1] = 'Raisin';
  print('Après modification : $fruits');  // [pomme, raisin, orange]

  // Obtenir la longueur
  print('Nombre de fruits : ${fruits.length}');

  // Vérifier si vide
  print('La liste est-elle vide ? ${fruits.isEmpty}');
  print('La liste est-elle non vide ? ${fruits.isNotEmpty}');
}
第一个水果: 苹果
最后一个: 橙子
修改后: [苹果, 葡萄, 橙子]
水果数量: 3
列表为空? false
列表非空? true

Opérations courantes sur les listes

Exemple

void main() {
  var list = ['EXAMPLE', 'Dart'];

  // Ajouter des éléments
  list.add('Flutter');           // Ajouter un élément
  list.addAll(['Google', 'AI']);  // Ajouter plusieurs éléments
  print('Après ajout : $list');

  // Insérer un élément (à une position spécifique)
  list.insert(1, 'Tutorial');
  print('Après insertion : $list');

  // Supprimer les éléments
  list.remove('AI');             // Supprimer par valeur
  list.removeAt(0);              // Supprimer par index
  list.removeLast();             // Supprimer le dernier
  print('Après suppression : $list');

  // Rechercher l'élément
  bool hasDart = list.contains('Dart');
  int index = list.indexOf('Dart');
  print('Contient Dart ? $hasDart, position : $index');

  // Trier
  var nums = [3, 1, 4, 1, 5, 9];
  nums.sort();
  print('Après tri : $nums');

  // Inverser
  var reversed = nums.reversed.toList();
  print('Après inversion : $reversed');

  // Obtenir la sous-liste
  var subList = nums.sublist(0, 3);
  print('3 premiers : $subList');
}
添加后: [EXAMPLE, Dart, Flutter, Google, AI]
插入后: [EXAMPLE, 教程, Dart, Flutter, Google, AI]
After deletion: [教程, Dart, Flutter]
包含 Dart? true, 位置: 1
排序后: [1, 1, 3, 4, 5, 9]
反转后: [9, 5, 4, 3, 1, 1]
前3个: [1, 1, 3]

Méthodes fonctionnelles sur List

La List de Dart prend en charge des méthodes fonctionnelles comme map, where et reduce, ce qui rend le traitement des données plus concis.

Exemple

void main() {
  var scores = [55, 78, 92, 60, 45, 88];

  // where : filtrer (conserver les éléments qui satisfont la condition)
  var passed = scores.where((s) => s >= 60);
  print('Score de réussite : $passed');

  // map : mapper (convertir chaque élément en une nouvelle valeur)
  var grades = scores.map((s) => s >= 60 ? 'Réussi' : 'Échec');
  print('Note: $grades');

  // where + map appel chaîné
  var highScores = scores
      .où((s) => s >= 80)
      .map((s) => 'Meilleur score: $s')
      .toList();
  print('Liste des meilleurs scores: $highScores');

  // reduce: calcul cumulatif
  var total = scores.reduce((sum, s) => sum + s);
  print('EXEMPLE score total: $total');

  // fold: calcul cumulatif avec une valeur initiale
  var avg = scores.fold(0, (sum, s) => sum + s) / scores.length;
  print('Score moyen : ${avg.toStringAsFixed(1)}');

  // any / every : vérification d'existence
  bool hasFullMark = scores.any((s) => s == 100);
  bool allPassed = scores.every((s) => s >= 60);
  print('Y a-t-il un score parfait ? $hasFullMark');
  print('Tous ont réussi ? $allPassed');
}
及格分数: (78, 92, 60, 88)
评级: (不及格, 及格, 及格, 及格, 不及格, 及格)
高分列表: [高分: 92, 高分: 88]
EXAMPLE 总分: 418
平均分: 69.7
有满分吗? false
全部及格? false

map() et where() retournent un Iterable (évaluation paresseuse). Vous devez le convertir en une List avec toList() pour que le calcul s'exécute réellement. Si vous n'avez besoin d'itérer qu'une seule fois, vous pouvez utiliser l'Iterable directement sans conversion.


Set : collection d'éléments uniques

Set est similaire à List, mais chaque élément d'un Set ne peut apparaître qu'une seule fois ; les doublons ne sont pas autorisés.

Set n'est pas ordonné, et les éléments ne sont pas accessibles par index.

Exemple

void main() {
  // Créer un Set (les éléments sont automatiquement dédupliqués)
  Set<String> tags = {'Dart', 'Flutter', 'Dart', 'EXAMPLE'};
  print('Ensemble de tags : $tags');  // {Dart, Flutter, EXAMPLE}, le doublon Dart a été supprimé
  print('Nombre de tags : ${tags.length}');  // 3

  // Ajouter des éléments
  tags.add('Google');
  tags.add('Dart');  // Dart existe déjà, il ne sera pas ajouté à nouveau
  print('Après ajout : $tags');

  // Supprimer les éléments
  tags.remove('Google');
  print('Après suppression : $tags');

  // Vérifier la présence
  print('Contient EXAMPLE ? ${tags.contains('EXAMPLE')}');

  // Opérations sur les ensembles
  var setA = {1, 2, 3, 4};
  var setB = {3, 4, 5, 6};

  print('Intersection: ${setA.intersection(setB)}');  // {3, 4}
  print('Union: ${setA.union(setB)}');          // {1, 2, 3, 4, 5, 6}
  print('Différence: ${setA.difference(setB)}');     // {1, 2}
}
标签集合: {Dart, Flutter, EXAMPLE}
标签数量: 3
添加后: {Dart, Flutter, EXAMPLE, Google}
After deletion: {Dart, Flutter, EXAMPLE}
包含 EXAMPLE? true
交集: {3, 4}
并集: {1, 2, 3, 4, 5, 6}
差集: {1, 2}

Le cas d'utilisation typique de Set est la déduplication. Lorsque vous n'avez pas besoin d'éléments en double, utiliser Set est bien plus efficace que de dédupliquer manuellement avec List.


Map: mappage de paires clé-valeur

Map est utilisé pour stocker des paires clé-valeur. Chaque clé correspond à une valeur.

Les clés dans une Map doivent être uniques; les valeurs peuvent être dupliquées.

Création et accès à une Map

Exemple

void main() {
  // Créer une Map avec des littéraux
  Map<String, String> siteInfo = {
    'name': 'EXEMPLE',
    'url': 'https://www.example.com',
    'type': 'Tutoriel de programmation',
  };

  // Accéder à la valeur par clé
  print('Nom du site : ${siteInfo['name']}');
  print('URL du site : ${siteInfo['url']}');

  // L'accès à une clé inexistante renvoie null
  print('Description : ${siteInfo['description']}');  // null

  // Ajouter/Modifier des paires clé-valeur
  siteInfo['language'] = 'chinois';
  siteInfo['name'] = 'example.com';  // Modifier la valeur d'une clé existante
  print('Après mise à jour : $siteInfo');

  // Obtenir toutes les clés et toutes les valeurs
  print('Toutes les clés : ${siteInfo.keys}');
  print('Toutes les valeurs : ${siteInfo.values}');

  // Vérifier si la clé existe
  print('La clé url existe-t-elle ? ${siteInfo.containsKey('url')}');
  print('La clé desc existe-t-elle ? ${siteInfo.containsKey('desc')}');
}
站点名称: EXAMPLE
站点 URL: https://www.example.com
描述: null
更新后: {name: example.com, url: https://www.example.com, type: 编程教程, language: 中文}
所有键: (name, url, type, language)
所有值: (example.com, https://www.example.com, 编程教程, 中文)
有 url 键? true
有 desc 键? false

Opérations courantes sur les Map

Exemple

void main() {
  var scores = {
    'example': 95,
    'Alice': 87,
    'Bob': 72,
  };

  // Parcourir une Map
  scores.forEach((name, score) {
    print('$name: $score points');
  });

  // Supprimer la paire clé-valeur
  scores.remove('Bob');
  print('Après suppression de Bob: $scores');

  // Obtenir la valeur ou la valeur par défaut
  int aliceScore = scores['Alice'] ?? 0;
  int eveScore = scores['Eve'] ?? 0;  // Si absent, renvoyer la valeur par défaut 0
  print('Alice: $aliceScore, Eve: $eveScore');

  // putIfAbsent: ajouter uniquement lorsque la clé est absente
  scores.putIfAbsent('example', () => 100);  // Existe déjà, ne pas ajouter
  scores.putIfAbsent('David', () => 80);    // Si absent, ajouter
  print('Final: $scores');

  // Obtenir la longueur
  print('Nombre de personnes: ${scores.length}');
}
example: 95 分
Alice: 87 分
Bob: 72 分
删除 Bob 后: {example: 95, Alice: 87}
Alice: 87, Eve: 0
最终: {example: 95, Alice: 87, David: 80}
人数: 3

Les clés dans un Map peuvent être de n'importe quel type (String, int, etc.), mais l'égalité des clés doit être significative. Lorsque vous utilisez des objets personnalisés comme clés, vous devez vous assurer que == et hashCode sont correctement implémentés.


Opérateurs de propagation de collection ... et ...?

L'opérateur de propagation peut "propager" les éléments d'une collection dans une autre collection.

Exemple

void main() {
  var basics = ['Dart', 'Flutter'];
  var advanced = ['Programmation asynchrone', 'Gestion d'état'];

  // ... opérateur de propagation: insérer des éléments d'une autre collection
  var allCourses = ['EXEMPLE Premiers pas', ...basics, ...advanced];
  print('Tous les cours: $allCourses');

  // ...? propagation sensible à null: ignorer si la collection est null
  List<String>? optionalList;  // Peut être null
  var safeList = ['Premier élément', ...?optionalList];
  print('Propagation sûre : $safeList');  // Uniquement le premier élément

  optionalList = ['Contenu supplémentaire'];
  safeList = ['Premier élément', ...?optionalList];
  print('Propagation non nulle : $safeList');
}
所有课程: [EXAMPLE 入门, Dart, Flutter, 异步编程, 状态管理]
安全展开: [第一项]
有值展开: [第一项, 额外内容]

if et for dans les collections (flux de contrôle des collections)

Dart permet d'utiliser if et for directement dans les littéraux de collection ; c'est un sucre syntaxique très utile.

Exemple

void main() {
  bool showAdmin = true;

  // if de collection : inclure conditionnellement des éléments
  var menuItems = [
    'Accueil',
    'Tutoriel',
    if (showAdmin) 'Panneau d’administration',  // Ajouter uniquement lorsque la condition est vraie
    'À propos',
  ];
  print('Menu : $menuItems');

  // for dans une collection : générer des éléments à partir d’une autre collection
  var numbers = [1, 2, 3];
  var doubled = [
    for (var n in numbers) n * 2,  // Itérer pour générer de nouveaux éléments
  ];
  print(Doublé : $doubled);

  // if + for peuvent être combinés
  var tags = ['Dart', 'Flutter'];
  var links = [
    'EXEMPLE Accueil',
    for (var tag in tags) 'https://example.com/$tag',
  ];
  print('Links: $links');
}
菜单: [首页, 教程, 管理后台, 关于]
翻倍: [2, 4, 6]
链接: [EXAMPLE 首页, https://example.com/Dart, https://example.com/Flutter]

Comparaison de trois collections

FonctionnalitésListeSetMap
ordreOrdonnéNon ordonnéNon ordonné (mais possède un ordre d'itération)
Doublons autorisésAutoriséNon autorisésLes clés doivent être uniques, les valeurs peuvent être dupliquées
Accès par indexPrend en charge []Non pris en chargeAccès via clé []
Scénarios typiquesListe ordonnée, séquenceDédoublonnage, collection de tagsMappage clé-valeur, éléments de configuration
Créer des littéraux[]{}{key: value}

Notes

Set et Map utilisent tous deux{}comme littéral.

La différence est :

  • Utilisation de Mapkey: valueforme (avec deux-points)
  • Set écrit directement les éléments (sans deux-points)

Par exemple :

var map = {'name': 'Tom'};   // Map
var set = {'Tom', 'Jerry'}; // Set

Attention particulière nécessaire :

var x = {};

Cela ne créera pas un Set vide ; à la place, Dart l'inférera comme :

Map<dynamic, dynamic>

Comme les accolades vides ne permettent pas de déterminer le type d'élément, Dart le traite par défaut comme un Map.

Pour créer un Set vide, vous devez explicitement spécifier :

var x = <String>{};

ou

:
Set<String> x = {};
autres extensions