Collections

// Creating
var list = [1, 2, 3];                           // List<int>
var growable = <int>[];                          // empty growable list
var fixed = List.filled(5, 0);                   // [0, 0, 0, 0, 0] — fixed length
var generate = List.generate(5, (i) => i * 2);   // [0, 2, 4, 6, 8]

// Spread operators
var a = [1, 2];
var b = [0, ...a, 3];                            // [0, 1, 2, 3]
List<int>? maybeNull;
var c = [0, ...?maybeNull, 3];                   // null-aware spread

// Collection if/for
var active = true;
var items = [1, if (active) 2, 3];               // [1, 2, 3]
var squares = [for (var i = 0; i < 3; i++) i * i]; // [0, 1, 4]

// Access
list[0];                    // 1
list.first;                  // 1
list.last;                   // 3
list.length;                 // 3
list.indexOf(2);            // 1
list.lastIndexOf(2);        // 1

// Add / remove (growable only)
list.add(4);                // [1, 2, 3, 4]
list.addAll([5, 6]);       // [1, 2, 3, 4, 5, 6]
list.insert(1, 99);         // insert at index 1
list.remove(3);             // removes first occurrence of 3
list.removeAt(0);           // removes element at index 0
list.removeLast();           // removes last element
list.removeRange(0, 2);     // removes range

// Transform
list.map((e) => e * 2);                   // [2, 4, 6]
list.where((e) => e > 1);                  // [2, 3]
list.expand((e) => [e, e]);                // [1, 1, 2, 2, 3, 3]
list.cast<num>();                          // List<num> — cast elements

// Sort
list.sort();                                // in-place sort
list.sort((a, b) => b.compareTo(a));        // descending
var sorted = [...list]..sort();              // sorted copy

// Find
list.firstWhere((e) => e > 1, orElse: () => -1);
list.lastWhere((e) => e > 1, orElse: () => -1);
list.indexWhere((e) => e > 1);
list.any((e) => e > 2);                    // true
list.every((e) => e > 0);                   // true

// Reduce / fold
list.reduce((a, b) => a + b);               // 6
list.fold<int>(0, (acc, e) => acc + e);    // 6

// Group by (since Dart 3)
var grouped = list.groupFoldBy<int, List<int>>(
  (e) => e % 2,
  (list, e) => list..add(e),
);
// {1: [1, 3], 0: [2]}

// Join to string
list.join(', ');                              // '1, 2, 3'

// Sublist
list.sublist(1, 3);                          // [2, 3]
list.getRange(1, 3);                          // Iterable(2, 3)

// Unique
var unique = list.toSet().toList();

// Creating
var set = {1, 2, 3};                          // Set<int>
var emptySet = <int>{};                        // empty Set
var fromList = {1, 2, 2, 3};                   // {1, 2, 3} — duplicates removed

// Add / remove
set.add(4);                                    // {1, 2, 3, 4}
set.addAll([5, 6]);                            // {1, 2, 3, 4, 5, 6}
set.remove(1);                                 // {2, 3, 4, 5, 6}

// Check membership
set.contains(2);                               // true

// Set operations
var a = {1, 2, 3};
var b = {2, 3, 4};

a.union(b);                                    // {1, 2, 3, 4}
a.intersection(b);                             // {2, 3}
a.difference(b);                               // {1}

// Creating
var map = {'a': 1, 'b': 2, 'c': 3};          // Map<String, int>
var mutable = <String, int>{};                  // empty mutable map
var empty = Map<String, int>();                 // empty map

// Access
map['a'];                                       // 1 — null if missing
map['z'] ?? 0;                                  // 0 — default value

// Add / update
mutable['x'] = 10;                              // add or update
mutable.addAll({'y': 20, 'z': 30});            // add all
mutable.update('x', (v) => v * 2);             // update existing
mutable.putIfAbsent('w', () => 40);             // add only if missing
mutable.updateAll((key, value) => value * 2);   // update all values

// Remove
mutable.remove('w');                             // removes key, returns value or null
mutable.removeWhere((key, value) => value < 10);

// Iterate
for (var key in map.keys) {
  print(key);
}

for (var value in map.values) {
  print(value);
}

map.forEach((key, value) {
  print('$key = $value');
});

// Properties
map.keys;           // Iterable of keys
map.values;         // Iterable of values
map.entries;        // Iterable of MapEntry
map.length;         // number of entries
map.isEmpty;         // true if no entries
map.isNotEmpty;      // true if has entries
map.containsKey('a'); // true
map.containsValue(1); // true

// Transform
map.map((key, value) => MapEntry(key.toUpperCase(), value * 2));

// Filter entries
map.entries.where((e) => e.value > 1).toList();

// From lists
var keys = ['a', 'b', 'c'];
var values = [1, 2, 3];
var combined = Map.fromIterables(keys, values);

// Functional operations
iterable.map((e) => e.transform);
iterable.where((e) => condition);
iterable.expand((e) => moreElements);
iterable.take(5);                   // first 5 elements
iterable.skip(3);                   // skip first 3
iterable.first;                      // first element (throws if empty)
iterable.last;                       // last element (throws if empty)
iterable.single;                     // single element (throws if 0 or 2+)
iterable.firstOrNull;               // first or null (Dart 3)
iterable.lastOrNull;                 // last or null (Dart 3)
iterable.singleOrNull;              // single or null (Dart 3)
iterable.any((e) => condition);
iterable.every((e) => condition);
iterable.forEach((e) => action);
iterable.reduce((a, b) => combined);
iterable.fold<int>(0, (acc, e) => acc + e);
iterable.toList();
iterable.toSet();