Mastering Dart Collections: A Comprehensive Guide For Flutter Developers

Dart, a powerful indeed versatile programming language, that is used to manage groups of data effectively. Dart collections are key data structures in Dart that allow for easy collection traversal and efficient data manipulation, similar to collections in other programming languages. Especially significant for Flutter developers, understanding Dart collections can unlock powerful programming techniques for versatile Flutter apps.

There are four types of collections in Dart: List, Set, Queue, and Map. However, we will focus on the primary ones, List and Set and their close relation, Map.

‍

Definition and Utility of Dart Collections

In Dart, a collection is an ordered group of items, unlike unordered collections in some other programming languages. Typically, they can contain elements, each of which can hold either simple variables or complex objects. A user can perform different operations, such as inserting, deleting, or finding items in a collection.

The primary advantage is a more organized way of handling data, making the code cleaner and more manageable. Let's explore the types of collections in Dart.

‍

The Connection Between Flutter and Dart Collections

Anyone who toys with the idea of Flutter invariably stumbles onto Dart sooner or later. That's because Dart is the programming language of choice for Flutter, mainly because of its excellent support for collection literals.

Collection literals in Dart can be used to define and create collections easily and quickly. It's the use case for these collection literals that makes Dart an ideal choice for Flutter.

The interactive code snippets below offer a glimpse of how Dart collections function. Note the void main function, which is obligatory in everyone Dart program.

Copy
1
2
3
4
5
6
7
8
9
     void main() {
      List<dynamic> grocery = ["Milk", "Bread", "Cheese"];
      print(grocery);
      Map<String, int> scoreCard = {"Alice": 450, "Bob": 300};
      print(scoreCard);
      Set<String> languages = {"C", "Java", "Python"};
      print(languages);
    }
     

This example illustrates the practical utility of three types of dart collection: List, Map, and Set.

‍

Understanding Basic Dart Collections

Just like setting up your toolkit before crafting a masterpiece, gaining knowledge about Dart collections lays a strong foundation for coding versatile Flutter apps.

‍

Lists: The Most Commonly Used Dart Collection

Perhaps the most familiar of all, the List class represents lists in Dart which is a dynamic collection. A List can be defined as an ordered group of items. The List class in Dart, part of its core library, encompasses methods that assist you in managing and manipulating lists.

Lists can be classified into two categories: a fixed-length list, a list's length that doesn’t change, and a growable list that can change its length dynamically.

Here is how you can define a List:

Copy
1
2
3
4
5
6
7
8
9
     void main() {
      var list = [1, 2, 3];
      // list literal
      print(list);
      List <String> otherList = List();
      // list class
      print(otherList);
    }
     

This code defines a List in Dart, first using a List literal, then using the List class.

‍

Sets: Undefined Order Collection

While Lists store an ordered group of items, a Set class represents an unordered collection of unique items. Similar to a List, a set can contain only one element of a specific value. It can be used when you want to make sure no duplicates are present.

Let's illustrate this with an example:

Copy
1
2
3
4
5
6
7
8
9
     void main() {
      var set = {'hello', 'world'};
      // set literal
      print(set);
      Set <String> anotherSet = Set();
      // set class
      print(anotherSet);
    }
     

This example demonstrates how to define a Set in Dart.

‍

Maps: Defining Key-Value Pairs

Maps in Dart are dynamic collections of key-value pairs. Each item in a Map has a key and a value associated with it. The Map class defines the operations for Maps.

Maps are written as a pair of keys and values in curly braces ({}). You can create maps with the Map() constructor or directly using {}.

Example of Map in Dart:

Copy
1
2
3
4
5
6
7
8
9
     void main() {
      var map = {'firstName': 'Alice', 'lastName': 'Johnson'};
      // map literal
      print(map);
      Map<String, int> anotherMap = Map();
      // map class
      print(anotherMap);
    }
     

This example shows the definition of a Map using the Map literal and the Map class.

‍

Digging Deeper into the dart:collection Library

Diving into Dart, we find that the dart:collection library is an essential part of the language. Collections are core components of any programming language, and Dart is no different. It comes with a rich core library which includes dart:collection, providing many functionalities that make handling Dart collections an enjoyable process.

‍

Overview of dart:collection

The dart:collection library provides a wide variety of classes to manipulate and process collections more efficiently. It includes classes for lists, sets, maps, and queues and also offers several additional utilities.

‍

Utility and Usage of dart:collection

The dart:collection library provides us with various tools for working with collections, like HashSet, LinkedHashMap, Queue, SplayTreeSet, and more. Among these tools, we will concentrate on a few of them:

• LinkedHashMap: A map linked list that maintains the insertion order of the map entries. Subsequent entry with the same key replaces the older one.
• HashSet: A set literal based on LinkedHashMap keeping just keys. It guarantees uniqueness in the Set with constant time cost.
• Queue: It primarily works on the concept of FIFO (First In First Out) strategy. It keeps the order and allows access to the first and last elements.

These classes, among others, provide you with everything you need to handle Dart collections efficiently.

‍

Dart Iterable: An Essential Component of Dart Collections

In the world of Dart collections, Iterable is a term that holds significant prominence. Iterable collections, like Lists and Sets, are collections of items that can be sequentially accessed.

‍

The Basic Concept of Dart Iterable

Dart Iterable is a collection of values, or "elements", that can be accessed sequentially. An Iterable in Dart contains methods that can be used for iterating collections of items, like Lists and Sets.

‍

Traversing through Collections

Iterable collections in Dart are equipped with the Iterator property which allows simple iterative actions such as moving to the next item or returning to the current property.

The Iterator class defines a pointer-like object. The methods provided by Iterator enable you to navigate through the elements of a collection.

This can be seen in the following example:

Copy
1
2
3
4
5
6
7
8
     void main() {
      var list = [1, 2, 3];
      var i = list.iterator;
      while(i.moveNext()) {
        print(i.current);
      }
    }
     

In this code snippet, we are traversing through the list using the Iterator class.

‍

Transforming and Filtering Collections

With dart:collection, you can transform and filter objects in your collection. Iterable's where() function lets you filter items from your collection based on a condition and gives the output as an Iterable.

Look at this transformation in the code snippet below:

Copy
1
2
3
4
5
6
     void main() {
      var list = [1, 2, 3, 4, 5];
      var evenNumbers = list.where((num) => num%2 == 0);
      print(evenNumbers);
    }
     

Here, we are obtaining even numbers from a list of numbers using the where function.

‍

Deep Dive into Some Methods of Dart Iterable

Dart’s Iterable class offers several methods which can be helpful while iterating the collections, such as map(), reduce(), expand(), etc.

‍

Application of Dart Collections in Flutter

Now that we’ve familiarized ourselves with Dart collections, it's time to understand how they play a pivotal role in Flutter development.

‍

Usage of Dart List Map within Flutter

Dart list maps are used profusely in Flutter, especially when dealing with a dynamic collection of widgets. For instance, let's say you want to generate a list of Text widgets dynamically. Here, a List Map becomes particularly handy.

An example of how dynamic lists can be built in Flutter:

Copy
1
2
3
4
5
6
7
8
     void main() {
      List<String> items = ['Item 1', 'Item 2', 'Item 3'];
      Column column = Column(
        children: items.map((item) => Text(item)).toList(),
      );
      print(column);
    }
     

In the above example, we are dynamically creating a list of Text widgets based on the values we have in the List of Strings.

‍

Harnessing Dart Iterable in Flutter Applications

While Dart Iterable is a remarkable feature, it shines excellently in Flutter applications. You can access various elements from an iterable easily, which is particularly useful for processing data inside widgets.

‍

Examples of Iterable Use Cases

Here, we will look at an example of how you can use iterable collections in Flutter.

‍

Converting a List to an Iterable

In some cases, you might receive a collection of data and need to display each datum as a widget. To do that, you need to convert the list to an Iterable first.

Copy
1
2
     var myIterable = myList.map((item) => new Text(item));
     

‍

Using Iterable to Apply a Function on Each Item of a Collection

With Iterable, you can use tools such as map and reduce to easily apply a function on each item within your collection.

Copy
1
2
     var myList = myIterable.toList();
     

This simple conversion can make building dynamic lists in Flutter way easier and more efficient.

‍

Explore Dart Collections in Your Flutter Journey!

In this blog, we have embarked on a detailed journey, exploring the essentials of Dart collections. With the knowledge you have gained, you are better equipped to leverage the power of Dart collections in your Flutter development journey, making your apps more dynamic, efficient, and adaptable. Taking the deal with data structures like lists, sets, maps, and queues, we carefully treaded on Dart's broad arsenal for handling collections, the dart:collection library. We also witnessed the exciting world of Iterables in Dart and how it aids in easy collection traversal, especially significant in Flutter applications. But the journey doesn't end here. As a developer, the world of Dart and Flutter provides an exciting landscape of continual learning and exploration. So keep exploring and coding! 🚀