Dart is versatile programming language that is popularity due to its simplicity and efficiency. Data structures play a crucial role in programming, allowing developers to organize and manipulate data effectively. Sets are one of the fundamental data structures used in Dart programming, offering unique characteristics and numerous applications.

Familiar with the topic? Play Quiz

Understanding Sets

Definition of sets

A set is an unordered collection of unique elements. Unlike lists or maps, sets do not allow duplicate values. Each element in a set is distinct, making it suitable for scenarios where uniqueness is essential.

Characteristics of sets

Sets have a few key characteristics that distinguish them from other data structures. Firstly, they are unordered, meaning that the order in which elements are added to a set is not preserved. Secondly, sets do not allow duplicate elements, automatically ensuring uniqueness. Finally, sets are mutable(they can be changed), allowing for the addition, removal, and modification of elements.

How sets differ from other data structures ?

Sets differ from lists and maps in several ways. Unlike lists, sets do not maintain a specific order for elements. This distinction makes sets more efficient for membership testing, as elements can be accessed in constant time. Sets also differ from maps because they do not store key-value pairs, only individual unique elements.

Use cases for sets in programming

Sets find applications in various programming scenarios. They are particularly useful when it is important to maintain a collection of unique items or when membership testing is a common operation. Sets can be leveraged in areas such as data processing, eliminating duplicates, and performing set operations like union, intersection, and difference.

Declaring Sets in Dart

Syntax for creating an empty set

To create an empty set in Dart, you can use the Set constructor without any arguments. This syntax initializes an empty set that can later be populated with elements.

Set<datatype> var_name = {}; 

Initializing a set with values

In Dart, sets can also be initialized with values directly. You can use the curly braces {} surrounding comma-separated elements to denote a set literal. Dart’s type inference allows you to omit the type specification when initializing a set.


  Set<String> emptySet = Set();

// Initializing a set with values
Set<int> numberSet = {1, 2, 3, 4, 5};

Operations on Sets

We can perform multiple operation with sets. The operations that we did in the primary school can be done programatically. Unions, Intersections, differences etc can be performed just like maths in dart.

Adding elements to a set

You can add elements to a set using the add method. This method takes an element as an argument and inserts it into the set. If the element already exists in the set, it will not be added again, ensuring that sets maintain uniqueness.


  void main() { 
   Set numberSet = {}; 

   for(var no in numberSet) { 



code Try Yourself

Removing elements from a set

Dart provides two methods for removing elements from a set: remove and clear. The remove method removes a specific element from the set, while the clear method removes all elements, resulting in an empty set.

remove() method

Since we now understand what a remove() will do to the sets, lets take understand by example:


  set_name.remove("<value to be removed>");


  void main() {
  Set<String> names = {"Jonne", "James", "Shusi"};

  print(" before removing ");

  /// removed the  passed value

  print("after removing");


  before removing 
{Jonne, James, Shusi}
after removing
{Jonne, Shusi}

code Try Yourself

clear() method

We learned clear method will remove all the elements from the set. Now let’s the actual working of clear method.




  void main() {
  Set<String> names = {"Jonne", "James", "Shusi"};

  print(" before clearing ");


  print("after clearing");


   before clearing 
{Jonne, James, Shusi}
after clearing

code Try Yourself

Checking membership

To check if a set contains a specific element, you can use the contains method. This method returns a boolean value indicating whether the element is present in the set or not.

contains() method

The contains() methods checks if there are any elements in a set that has a match with the passed value. Let’s see how that works,


set_name.contains("<Value to be checked>"); 


  void main() {
  Set<String> names = {"Jonne", "James", "Shusi"};




code Try Yourself

containsAll() method

The containsAll() methods checks if there are all the elements in a set that has a match with the passed value. Let’s see how that works,


set_name.containsAll(<set of value to check for>); 


  void main() {
  Set<String> names = {"Jonne", "James", "Shusi"};

  print(names.containsAll({"James", "Charlie"}));



code Try Yourself

Set operations

Sets in Dart support various set operations, such as union, intersection, and difference. The union operation combines two sets into a single set, containing all the elements from both sets. The intersection operation creates a new set that only includes elements present in both sets. Finally, the difference operation generates a set that contains elements from the first set that are not present in the second set.


  Set<int> set1 = {1, 2, 3};
Set<int> set2 = {3, 4, 5};

Set<int> unionSet = set1.union(set2); // {1, 2, 3, 4, 5}
Set<int> intersectionSet = set1.intersection(set2); // {3}
Set<int> differenceSet = set1.difference(set2); // {1, 2} 


{1, 2, 3, 4, 5}
{1, 2}

code Try Yourself

Iterating Over Sets

Using loops to iterate over sets

You can iterate over sets using loops like for-in or forEach. The for-in loop allows you to iterate over each element in a set, providing access to its value. This approach is useful when you need to perform custom operations on each element.

Iterating using forEach method

Dart’s Set class also provides a forEach method that simplifies set iteration. This method takes a callback function as an argument and applies it to each element in the set. The callback function receives the current element as a parameter, allowing you to perform specific actions.


  Set<String> names = {'Alice', 'Bob', 'Charlie'};

// Using for-in loop
for (var name in names) {
  print('Hello, $name!');

// Using forEach method
names.forEach((name) {
  print('Goodbye, $name!');


  Hello, Alice!
Hello, Bob!
Hello, Charlie!
Goodbye, Alice!
Goodbye, Bob!
Goodbye, Charlie!

code Try Yourself

Set Properties and Methods

Length of a set

In Dart, you can determine the length of a set using the length property. This property returns the number of elements present in the set.

Checking if a set is empty

To check if a set is empty, you can use the isEmpty property. It returns a boolean value indicating whether the set is empty or not.


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

// Getting the length of a set
  int length = set.length; // 5

// Checking if a set is empty
  bool isEmpty = set.isEmpty; // false

  print("Length : $length");
  print("isEmpty: $isEmpty");


  Length : 5
isEmpty: false

code Try Yourself

Sets and Equality

Understanding equality in sets

In Dart, sets are compared based on the equality of their elements. Two sets are considered equal if they have the same elements, regardless of the order in which they were added.

Equality and identical sets

Identical sets are sets that reference the same memory location. Two sets may contain the same elements but reside in different memory locations. In Dart, you can use the identical function to determine if two sets are identical.


  void main() {
Set<int> set1 = {1, 2, 3};
Set<int> set2 = {3, 2, 1};
Set<int> set3 = set1;

bool areEqual = set1 == set2; // true
bool areIdentical = identical(set1, set3);
  print("areEqual : $areEqual"); 
  print("areIdentical: $areIdentical");

Practical Use Cases

Real-world scenarios where sets are beneficial

Sets have practical use cases in various domains. They are particularly beneficial when dealing with large datasets, as sets offer efficient membership testing. Sets can be used for eliminating duplicate records, filtering unique items, and performing set operations on data.

Examples from Dart libraries or frameworks that leverage sets

In the Flutter framework, sets are commonly used in the widget tree hierarchy. Each widget in Flutter is uniquely identified by a set of properties. By leveraging sets, Flutter efficiently compares widgets for changes, allowing for optimized rendering and improved performance.

Best Practices

Tips for efficient use of sets in Dart

  • Use sets when uniqueness is essential to avoid duplications.

  • Leverage set operations to perform calculations on distinct elements.

  • Consider using sets when membership testing a frequent operation.

Common pitfalls and how to avoid them

For to specify the type when creating a set can lead to unexpected behavior. Always specify the type explicitly to ensure consistency.

Be cautious when modifying a set during iteration. It is recommended to create a copy of the set iterate over, instead of modifying the original set.


Sets are crucial data structures in Dart programming, offering unique characteristics and numerous applications. They allow developers to efficiently handle collections of unique elements and perform set operations. By understanding sets and their operations, programmers can leverage the versatility and power of sets in their Dart programs.


You can test your understanding with the questions we prepared, it will take less than 4 minutes.