Dart Lesson 3:Collection Types (Part 1) — Using List and Set

Today we'll be learning about extremely important collection types in Dart. In this lesson, we'll focus on List and Set - powerful tools for managing and manipulating multiple data items efficiently in your programs.

I. List: An Ordered Collection of Data

A List is the most commonly used collection type in Dart. It's an ordered and allowing duplicates collection of data, similar to arrays in other programming languages.

1. How to Create a List

There are several ways to create a List, with these being the most common:

Method 1: Using literals (Recommended)

void main() {
  // Create a list of integers
  List<int> numbers = [1, 2, 3, 4, 5];

  // Create a list of strings
  List<String> fruits = ['Apple', 'Banana', 'Orange'];

  // Create a list with mixed types (not recommended, specify types when possible)
  List<dynamic> mixed = [1, 'hello', true, 3.14];

  print(numbers); // Output: [1, 2, 3, 4, 5]
  print(fruits); // Output: [Apple, Banana, Orange]
}

Method 2: Using List constructors

void main() {
  // Create an empty list
  List<String> emptyList = List.empty();

  // Create a fixed-length list (initialized with a value)
  List<int> fixedList = List.filled(3, 0); // Length 3, initial value 0
  print(fixedList); // Output: [0, 0, 0]

  // Create a growable list
  List<String> growableList = List<String>.empty(growable: true);
  growableList.add('dart');
  print(growableList); // Output: [dart]
}

2. Accessing and Modifying List Elements

List elements are accessed using indices (starting from 0):

void main() {
  List<String> colors = ['Red', 'Green', 'Blue'];

  // Access elements
  print(colors[0]); // Output: Red
  print(colors[2]); // Output: Blue

  // Modify elements
  colors[1] = 'Yellow';
  print(colors); // Output: [Red, Yellow, Blue]

  // Get list length
  print(colors.length); // Output: 3
}

3. Adding and Removing Elements

For growable lists, we can dynamically add or remove elements:

void main() {
  List<int> nums = [10, 20];

  // Add a single element
  nums.add(30);
  print(nums); // Output: [10, 20, 30]

  // Add multiple elements
  nums.addAll([40, 50]);
  print(nums); // Output: [10, 20, 30, 40, 50]

  // Insert element at specific position
  nums.insert(1, 15); // Insert 15 at index 1
  print(nums); // Output: [10, 15, 20, 30, 40, 50]

  // Remove element by value (removes first occurrence)
  nums.remove(20);
  print(nums); // Output: [10, 15, 30, 40, 50]

  // Remove element by index
  nums.removeAt(0);
  print(nums); // Output: [15, 30, 40, 50]

  // Clear the list
  nums.clear();
  print(nums); // Output: []
}

4. Iterating Over Lists

Traversing lists is a common operation, with the for-in loop being most frequently used:

void main() {
  List<String> languages = ['Dart', 'Java', 'Python', 'JavaScript'];

  // Method 1: for-in loop (Recommended)
  for (String lang in languages) {
    print(lang);
  }

  // Method 2: Standard for loop (when index is needed)
  for (int i = 0; i < languages.length; i++) {
    print('Index $i: ${languages[i]}');
  }

  // Method 3: forEach method (functional programming style)
  languages.forEach((lang) {
    print('Language: $lang');
  });
}

II. Set: An Unordered Collection with Unique Elements

A Set is an unordered collection of unique elements, ideal for storing data where you don't want duplicates.

1. Creating a Set

void main() {
  // Method 1: Using literals (note the curly braces)
  Set<int> numbers = {1, 2, 3, 4};

  // Method 2: Using Set constructor
  Set<String> fruits = Set.from([
    'Apple',
    'Banana',
    'Apple',
  ]); // Automatically removes duplicates

  print(numbers); // Output: {1, 2, 3, 4}
  print(fruits); // Output: {Apple, Banana} (duplicate "Apple" is removed)

  // Creating empty Sets - compatible with all Dart versions
  Set<String> emptySet1 = <String>{}; // Recommended literal syntax
  Set<String> emptySet2 = Set<String>(); // Constructor syntax

  print(emptySet1.isEmpty); // Output: true
  print(emptySet2.isEmpty); // Output: true
}

Note: {} creates a Set by default, not a Map (which we'll learn about later). If you want to create an empty Map, specify the type with Map().

2. Core Feature of Set: Automatic Duplicate Removal

When adding duplicate elements, Set automatically ignores them:

void main() {
  Set<String> names = {'Zhang San', 'Li Si', 'Zhang San'};
  print(names);  // Output: {Zhang San, Li Si}

  // Adding a duplicate element
  names.add('Li Si');
  print(names);  // Output: {Zhang San, Li Si} (no change)
}

This feature is very useful for deduplication tasks:

void main() {
  // Original list with duplicates
  List<int> rawData = [1, 2, 2, 3, 3, 3, 4];

  // Convert to Set for deduplication, then back to List
  List<int> uniqueData = rawData.toSet().toList();

  print(uniqueData); // Output: [1, 2, 3, 4]
}

3. Set Operations: Intersection, Union, and Difference

Set provides convenient methods for set operations:

• Union: All elements from both sets (without duplicates)
• Intersection: Elements common to both sets
• Difference: Elements in the current set that are not in the other set

void main() {
  Set<int> a = {1, 2, 3, 4};
  Set<int> b = {3, 4, 5, 6};

  // Union: all elements from a and b
  Set<int> union = a.union(b);
  print(union); // Output: {1, 2, 3, 4, 5, 6}

  // Intersection: elements common to both a and b
  Set<int> intersection = a.intersection(b);
  print(intersection); // Output: {3, 4}

  // Difference: elements in a that are not in b
  Set<int> difference = a.difference(b);
  print(difference); // Output: {1, 2}
}

4. Adding and Removing Elements in Set

Set operations are similar to List, but since it's unordered, there are no index-related methods:

void main() {
  Set<String> countries = {'China', 'USA'};

  // Add an element
  countries.add('Japan');
  print(countries); // Output: {China, USA, Japan} (order may vary)

  // Add multiple elements
  countries.addAll(['France', 'Germany']);
  print(countries); // Output: {China, USA, Japan, France, Germany}

  // Remove an element
  countries.remove('USA');
  print(countries); // Output: {China, Japan, France, Germany}

  // Clear the set
  countries.clear();
  print(countries); // Output: {}
}

III. Common Collection Methods (map/where/toList etc.)

Dart collections provide many powerful methods that allow us to process data more concisely. These methods work with both Lists and Sets.

1. map(): Transform Elements

The map() method transforms each element in a collection according to specified rules and returns a new iterable:

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

  // Multiply each number by 2
  var doubled = numbers.map((n) => n * 2);

  // map() returns an Iterable, often converted to List
  List<int> doubledList = doubled.toList();

  print(doubledList); // Output: [2, 4, 6, 8]

  // String processing example
  List<String> names = ['Zhang San', 'Li Si', 'Wang Wu'];
  List<String> greetings = names.map((name) => 'Hello, $name!').toList();
  print(
    greetings,
  ); // Output: [Hello, Zhang San!, Hello, Li Si!, Hello, Wang Wu!]
}

2. where(): Filter Elements

The where() method filters elements based on a condition and returns an iterable containing elements that meet the condition:

void main() {
  List<int> ages = [12, 18, 20, 15, 25, 30];

  // Filter adults (age >= 18)
  var adults = ages.where((age) => age >= 18);

  List<int> adultList = adults.toList();
  print(adultList); // Output: [18, 20, 25, 30]

  // Set filtering example
  Set<double> prices = {19.9, 29.9, 9.9, 39.9, 5.9};
  List<double> cheapPrices = prices.where((p) => p < 20).toList();
  print(cheapPrices); // Output: [19.9, 9.9, 5.9]
}

3. toList() and toSet(): Type Conversion

These methods convert between List and Set:

void main() {
  Set<String> set = {'a', 'b', 'c'};
  List<String> list = set.toList(); // Set to List
  print(list); // Output: [a, b, c] (order may vary)

  List<String> duplicateList = ['a', 'a', 'b'];
  Set<String> uniqueSet = duplicateList
      .toSet(); // List to Set (removes duplicates)
  print(uniqueSet); // Output: {a, b}
}

4. contains(): Check if an Element Exists

void main() {
  List<String> fruits = ['Apple', 'Banana', 'Orange'];
  print(fruits.contains('Banana')); // Output: true
  print(fruits.contains('Watermelon')); // Output: false

  Set<int> nums = {1, 3, 5};
  print(nums.contains(3)); // Output: true
}

5. any() and every(): Evaluate Conditions

• any(): Returns true if at least one element satisfies the condition
• every(): Returns true only if all elements satisfy the condition

void main() {
  List<int> scores = [85, 92, 78, 60];

  // Are there any failing scores (<60)?
  bool hasFailed = scores.any((s) => s < 60);
  print(hasFailed); // Output: false (all are >=60)

  // Did all scores pass?
  bool allPassed = scores.every((s) => s >= 60);
  print(allPassed); // Output: true
}

IV. Differences Between List and Set, and When to Use Each

Feature	List	Set
Order	Ordered (preserves insertion order)	Unordered (partially ordered in Dart 3.0+)
Duplicates	Allows duplicate elements	No duplicate elements
Index access	Supported (via index)	Not supported (no index)
Lookup speed	Decreases with more elements	Consistently high (hash table implementation)

Recommendation:

• Use List when you need to maintain element order or allow duplicates
• Use Set when you need to avoid duplicates or efficiently check for element existence
• Use Set when you need to perform frequent set operations (intersection, union, etc.)