Skip to content
### Dart Set

## Mastering Dart Sets| A Comprehensive Guide with Examples

#### Introduction:

##### Here’s a basic example of how you can work with sets in Dart:

###
step by step how to create set in dart

#### Here’s a step-by-step guide:

##### Step 1: Import the dart:core library

#####
Step 2: Declare a Set variable and initialize it with elements

##### Step 3: Optionally, you can omit the type argument if Dart can infer it.

##### Step 4: Optionally, you can also create an empty set and then add elements to it.

##### Step 5: Use the set for various operations like adding, removing, checking for existence, or iterating over its elements.

#### complete example with explanation

#### Explanation:

### The ways to create sets in Dart

#### Using Set Literals:

#### Using the Set Constructor:

#### Using the toSet() Method:

#### Using a Typed or Untyped Set Literal:

#### Using the Set Constructor with Named Parameters:

####
complet example about thes ways with explanation

#### Explanation:

###
The methods that are used with Dart set

#### add(E element):

#### addAll(Iterable<E> elements):

#### clear():

#### contains(Object? element):

#### difference(Set<Object?> other):

#### intersection(Set<Object?> other):

#### isEmpty:

#### isNotEmpty:

#### length:

#### remove(Object? element):

#### removeAll(Iterable<Object?> elements):

#### retainAll(Iterable<Object?> elements):

#### containsAll(Iterable<Object?> other):

#### union(Set<Object?> other):

#### forEach(void Function(E) f):

#### toList():

#### toSet():

#### intersectionEquals(Set<E> other):

#### lookup(Object? object):

#### map<T>(T Function(E) f):

####
complete exampless about these methods

#### Explanation:

#### Uses the Dart sets with examples

#### Explanation:

###
An application about Dart Sets

#### Explanation:

### Quiz about this lesson:15 questions

#### 1-What is a set in Dart?

#### 2-How do you create a set in Dart using set literals?

#### 3-Which method is used to add an element to a set in Dart?

#### 4-What does the addAll method do in Dart sets?

#### 5-Which method is used to check if a set contains a specific element in Dart?

#### 6-What does the difference method return in Dart sets?

#### 7-How do you find the intersection of two sets in Dart?

#### 8-Which property is used to check if a set is empty in Dart?

#### 9-How do you remove an element from a set in Dart?

#### 10-What is the purpose of the clear method in Dart sets?

#### 11-How do you convert a set to a list in Dart?

#### 12-Which method is used to apply a function to each element in a set in Dart?

#### 13-What does the containsAll method do in Dart sets?

#### 14-Which method is used to find the union of two sets in Dart?

#### 15-How do you create an empty set in Dart?

#### Answers:

- الرئيسية
- أحدث المقالات
- دارت | فلاتر

Welcome to our comprehensive guide on mastering sets in Dart programming language. Sets are a fundamental data structure that allows you to store unique elements. In this lesson, we will explore everything you need to know about sets in Dart, including how to create sets, perform various operations on them, and use them effectively in your Dart programs.

In Dart programming language, a Set is a collection of unique elements, meaning that each element can only appear once in the set. Sets in Dart are unordered collections, which means the order in which elements are added to the set is not guaranteed to be preserved. Dart’s Set is similar to mathematical sets in that it does not allow duplicate elements.

dart

void main() { // Creating a set Set<int> numbers = {1, 2, 3, 4, 5}; // Adding elements to the set numbers.add(6); numbers.addAll([7, 8, 9]); // Removing elements from the set numbers.remove(5); // Checking if an element exists in the set print(numbers.contains(4)); // Output: true print(numbers.contains(10)); // Output: false // Iterating over the elements of the set for (var number in numbers) { print(number); } // Creating an empty set Set<String> names = {}; // Adding elements to the set names.add('Alice'); names.addAll(['Bob', 'Charlie']); // Removing elements from the set names.remove('Bob'); // Checking the length of the set print(names.length); // Output: 2 }

In this example, numbers is a set of integers, and names is a set of strings. You can perform various operations on sets, such as adding elements, removing elements, checking if an element exists, iterating over the elements, and checking the length of the set.

Creating a set in Dart is straightforward.

dart

import ‘dart:core’;

dart

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

This line declares a set named mySet containing integer elements 1, 2, 3, 4, and 5.

dart

var mySet = {1, 2, 3, 4, 5};

dart

Set<int> myEmptySet = {}; myEmptySet.add(1); myEmptySet.add(2); myEmptySet.add(3);

dart

// Adding an element mySet.add(6); // Removing an element mySet.remove(3); // Checking if an element exists bool containsElement = mySet.contains(4); print(containsElement); // Output: true // Iterating over the elements for (var element in mySet) { print(element); } // Checking the length of the set print(mySet.length);

That’s it! You’ve successfully created a set in Dart and performed basic operations on it.

Sets are useful for storing unique elements and performing set operations like union, intersection, and difference.

Here’s a complete example of creating a set in Dart with explanations:

dart

void main() { // Step 1: Import the dart:core library (optional as it's automatically imported) // import 'dart:core'; // Step 2: Declare a Set variable and initialize it with elements Set<int> mySet = {1, 2, 3, 4, 5}; // Step 3: Optionally, you can omit the type argument if Dart can infer it // var mySet = {1, 2, 3, 4, 5}; // Step 4: Optionally, you can also create an empty set and then add elements to it Set<int> myEmptySet = {}; myEmptySet.add(1); myEmptySet.add(2); myEmptySet.add(3); // Step 5: Use the set for various operations like adding, removing, checking for existence, // or iterating over its elements. // Adding an element mySet.add(6); // Removing an element mySet.remove(3); // Checking if an element exists bool containsElement = mySet.contains(4); print("Does mySet contain 4? $containsElement"); // Output: true // Iterating over the elements print("Elements in mySet:"); for (var element in mySet) { print(element); } // Checking the length of the set print("Length of mySet: ${mySet.length}"); // Step 6: Sets in Dart are unordered, so elements may not be in the order they were added. // You can't access elements by index like in lists. }

Importing dart:core library: Dart’s Set class is part of the core library, so you typically don’t need to import it explicitly as it’s automatically imported in Dart programs.

Declaring and initializing a set: You declare a set by specifying the type of elements it will contain (int in this case) and then initializing it with a list of elements enclosed in curly braces {}.

Adding elements to an empty set: You can also create an empty set and then add elements to it using the add method.

Using the set for operations: You can perform various operations on sets like adding elements (add), removing elements (remove), checking if an element exists (contains), iterating over the elements, and getting the length of the set.

Iterating over the elements: We use a for-in loop to iterate over the elements of the set and print each element.

Sets are unordered: Sets in Dart are unordered collections, so the order in which elements are stored is not guaranteed to be the same as the order in which they were added. You cannot access elements by index like in lists.

In Dart, there are multiple ways to create sets. Here are the different approaches:

Set literals allow you to create sets directly with a concise syntax using curly braces {}. Elements are separated by commas.

dart

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

You can use the Set constructor to create a set from an iterable, such as a list. This allows you to convert other iterable collections into sets.

dart

Set<int> mySet = Set<int>.from([1, 2, 3, 4, 5]);

The toSet() method can be used on iterables like lists to create a new set containing all the unique elements from the iterable.

dart

List<int> myList = [1, 2, 3, 4, 5]; Set<int> mySet = myList.toSet();

Dart allows you to create sets without explicitly specifying the type. In this case, Dart infers the type of the set elements.

dart

var mySet = {1, 2, 3, 4, 5}; // Dart infers the type based on the elements

The Set constructor also accepts named parameters like of and identity for more specific use cases.

dart

Set<int> mySet = Set<int>.of([1, 2, 3, 4, 5]); Set<int> myIdentitySet = Set<int>.identity();

These are the main ways to create sets in Dart. Depending on your requirements and preferences, you can choose the most suitable method for your use case.

let’s create a complete example demonstrating each of the ways to create sets in Dart along with explanations:

dart

void main() { // 1. Using Set Literals Set<int> setLiteral = {1, 2, 3, 4, 5}; print('Set created using set literals: $setLiteral'); // 2. Using the Set Constructor Set<int> setConstructor = Set<int>.from([1, 2, 3, 4, 5]); print('Set created using Set constructor: $setConstructor'); // 3. Using the toSet() Method List<int> list = [1, 2, 3, 4, 5]; Set<int> setFromList = list.toSet(); print('Set created using toSet() method: $setFromList'); // 4. Using a Typed or Untyped Set Literal var inferredSet = {1, 2, 3, 4, 5}; // Dart infers the type based on elements print('Set created using inferred type: $inferredSet'); // 5. Using the Set Constructor with Named Parameters Set<int> setConstructorOf = Set<int>.of([1, 2, 3, 4, 5]); print('Set created using Set.of(): $setConstructorOf'); Set<int> identitySet = Set<int>.identity(); print('Identity set created using Set.identity(): $identitySet'); }

Using Set Literals: Sets can be created directly using curly braces {} and adding elements separated by commas. Dart infers the type of the set from the elements provided.

Using the Set Constructor: The Set constructor allows you to create a set from an iterable (in this case, a list). You specify the type of elements explicitly.

Using the toSet() Method: Lists can be converted to sets using the toSet() method. This method creates a new set containing all the unique elements from the list.

Using a Typed or Untyped Set Literal: Dart allows you to create sets without explicitly specifying the type. In this case, Dart infers the type of the set elements.

Using the Set Constructor with Named Parameters: The Set constructor also accepts named parameters like of and identity. Set.of() creates a set from an existing iterable, and Set.identity() creates an identity set, which compares elements by identity rather than equality.

Each approach achieves the same result of creating a set with the given elements, but they offer different levels of explicitness and flexibility depending on the specific use case.

Here are the various methods available for use with Dart sets:

Adds the specified element to the set if it is not already present.

Adds all elements of the specified iterable to the set.

Removes all elements from the set.

Returns true if the set contains the specified element.

Returns a new set containing all elements that are in this set but not in the other set.

Returns a new set containing all elements that are present in both this set and the other set.

Returns true if the set is empty.

Returns true if the set is not empty.

Returns the number of elements in the set.

Removes the specified element from the set if it is present.

Removes all elements in the specified iterable from the set.

Removes all elements from the set that are not present in the specified iterable.

Returns true if all elements in the specified iterable are present in the set.

Returns a new set containing all elements that are present in either this set or the other set.

Applies the specified function to each element in the set.

Converts the set to a list.

Returns the set itself. This method exists for compatibility reasons and simply returns the set unchanged.

Removes all elements that are not in both this set and the other set.

Looks up the first object in the set that has a hash code and equality operator equal to object.

Returns a new set containing the results of applying the given function f to each element of this set.

These methods provide various functionalities for manipulating and working with sets in Dart. Depending on the task at hand, you can choose the appropriate method to use with sets.

let’s provide complete examples for each method along with explanations:

dart

void main() { // Creating a set Set<int> mySet = {1, 2, 3, 4, 5}; // add(E element): Adds the specified element to the set if it is not already present. mySet.add(6); print('After adding 6: $mySet'); // addAll(Iterable<E> elements): Adds all elements of the specified iterable to the set. mySet.addAll([7, 8, 9]); print('After adding multiple elements: $mySet'); // contains(Object? element): Returns true if the set contains the specified element. print('Contains 3: ${mySet.contains(3)}'); // difference(Set<Object?> other): Returns a new set containing all elements that are in this set but not in the other set. Set<int> otherSet = {3, 4, 5, 10}; print('Difference with otherSet: ${mySet.difference(otherSet)}'); // intersection(Set<Object?> other): Returns a new set containing all elements that are present in both this set and the other set. print('Intersection with otherSet: ${mySet.intersection(otherSet)}'); // isEmpty: Returns true if the set is empty. print('Is the set empty? ${mySet.isEmpty}'); // isNotEmpty: Returns true if the set is not empty. print('Is the set not empty? ${mySet.isNotEmpty}'); // length: Returns the number of elements in the set. print('Length of the set: ${mySet.length}'); // remove(Object? element): Removes the specified element from the set if it is present. mySet.remove(5); print('After removing 5: $mySet'); // removeAll(Iterable<Object?> elements): Removes all elements in the specified iterable from the set. mySet.removeAll([7, 8]); print('After removing multiple elements: $mySet'); // retainAll(Iterable<Object?> elements): Removes all elements from the set that are not present in the specified iterable. mySet.retainAll([1, 2, 3, 4]); print('After retaining only 1, 2, 3, 4: $mySet'); // containsAll(Iterable<Object?> other): Returns true if all elements in the specified iterable are present in the set. print('Contains all [1, 2, 3]? ${mySet.containsAll([1, 2, 3])}'); // union(Set<Object?> other): Returns a new set containing all elements that are present in either this set or the other set. print('Union with otherSet: ${mySet.union(otherSet)}'); // forEach(void Function(E) f): Applies the specified function to each element in the set. mySet.forEach((element) { print('Element: $element'); }); // toList(): Converts the set to a list. List<int> myList = mySet.toList(); print('Converted to list: $myList'); // toSet(): Returns the set itself. Set<int> newSet = mySet.toSet(); print('New set created using toSet(): $newSet'); }

**add(E element):** Adds the element 6 to the set.

**addAll(Iterable<E> elements):** Adds multiple elements to the set.

**contains(Object? element):** Checks if the set contains the element 3.

**difference(Set<Object?> other):** Finds the elements that are in mySet but not in otherSet.

**intersection(Set<Object?> other):** Finds the elements that are present in both mySet and otherSet.

**isEmpty:** Checks if the set is empty.

**isNotEmpty:** Checks if the set is not empty.

**length:** Returns the length of the set.

**remove(Object? element):** Removes the element 5 from the set.

**removeAll(Iterable<Object?> elements):** Removes multiple elements from the set.

**retainAll(Iterable<Object?> elements):** Retains only the elements present in the specified iterable.

**containsAll(Iterable<Object?> other):** Checks if the set contains all elements of the specified iterable.

**union(Set<Object?> other):** Creates a new set containing all elements from both sets.

**forEach(void Function(E) f):** Executes a function for each element in the set.

**toList():** Converts the set to a list.

**toSet():** Returns the set itself.

let’s explore various operations on Dart sets with examples and explanations:

dart

void main() { // Creating two sets Set<int> set1 = {1, 2, 3, 4, 5}; Set<int> set2 = {4, 5, 6, 7, 8}; // 1. Union: Finding all unique elements present in both sets Set<int> unionSet = set1.union(set2); print('Union of set1 and set2: $unionSet'); // 2. Intersection: Finding common elements present in both sets Set<int> intersectionSet = set1.intersection(set2); print('Intersection of set1 and set2: $intersectionSet'); // 3. Difference: Finding elements present in set1 but not in set2 Set<int> differenceSet1 = set1.difference(set2); print('Difference (set1 - set2): $differenceSet1'); // 4. Difference: Finding elements present in set2 but not in set1 Set<int> differenceSet2 = set2.difference(set1); print('Difference (set2 - set1): $differenceSet2'); // 5. Checking for Subset: Checking if set1 is a subset of set2 bool isSubset = set1.isSubsetOf(set2); print('Is set1 a subset of set2? $isSubset'); // 6. Checking for Superset: Checking if set2 is a superset of set1 bool isSuperset = set2.isSupersetOf(set1); print('Is set2 a superset of set1? $isSuperset'); // 7. Removing an Element set1.remove(3); print('Set1 after removing 3: $set1'); // 8. Clearing a Set set2.clear(); print('Set2 after clearing: $set2'); // 9. Checking for Empty Set print('Is set2 empty? ${set2.isEmpty}'); }

**Union:** The union of two sets contains all the unique elements present in both sets.

**Intersection:** The intersection of two sets contains elements that are common to both sets.

**Difference:** The difference between two sets contains elements present in one set but not in the other set.

**Subset:** A set is considered a subset of another set if all elements of the first set are present in the second set.

**Superset:** A set is considered a superset of another set if it contains all elements of the second set.

**Removing an Element:** You can remove an element from a set using the remove method.

**Clearing a Set:** The clear method removes all elements from the set.

**Checking for Empty Set:** The isEmpty property returns true if the set is empty.

let’s create a simple Dart application that demonstrates the use of sets.

In this application, we’ll create a program that helps a manage their favorite movies using sets. The can add, remove, and view their favorite movies.

dart

import 'dart:io'; void main() { // Create an empty set to store favorite movies Set<String> favoriteMovies = {}; // Main application loop while (true) { print('---- Favorite Movies Management ----'); print('1. Add a movie'); print('2. Remove a movie'); print('3. View all favorite movies'); print('4. Exit'); // Get choice stdout.write('Enter your choice: '); String choice = stdin.readLineSync()!; switch (choice) { case '1': addMovie(favoriteMovies); break; case '2': removeMovie(favoriteMovies); break; case '3': viewMovies(favoriteMovies); break; case '4': exit(0); // Exit the application break; default: print('Invalid choice. Please try again.'); } } } // Function to add a movie to the set void addMovie(Set<String> movies) { stdout.write('Enter the name of the movie: '); String movie = stdin.readLineSync()!; movies.add(movie); print('Movie "$movie" added to favorites.'); } // Function to remove a movie from the set void removeMovie(Set<String> movies) { stdout.write('Enter the name of the movie to remove: '); String movie = stdin.readLineSync()!; if (movies.remove(movie)) { print('Movie "$movie" removed from favorites.'); } else { print('Movie "$movie" is not in your favorites.'); } } // Function to view all favorite movies void viewMovies(Set<String> movies) { print('Your Favorite Movies:'); if (movies.isEmpty) { print('No movies added yet.'); } else { for (var movie in movies) { print(movie); } } }

We start by importing the dart:io library to handle input and output operations.

We create an empty set favoriteMovies to store the ‘s favorite movies.

Inside the main application loop, we display a menu of options for the to choose from: add a movie, remove a movie, view all favorite movies, or exit the application.

Depending on the ‘s choice, we call corresponding functions (addMovie, removeMovie, viewMovies) to perform the desired operation.

The addMovie function prompts the to enter the name of the movie and adds it to the set of favorite movies.

The removeMovie function prompts the to enter the name of the movie they want to remove. If the movie is found in the set, it’s removed; otherwise, a message is displayed indicating that the movie is not in the favorites.

The viewMovies function displays all the favorite movies stored in the set. If the set is empty, it displays a message indicating that no movies have been added yet.

The program continues running in a loop until the chooses to exit by entering ‘4’.

Here’s a quiz about sets in Dart with 15 questions:

A) A collection of ordered elements

B) A collection of unique elements

C) A collection of key-value pairs

A) Using square brackets []

B) Using curly braces {}

C) Using parentheses ()

A) add()

B) insert()

C) append()

A) Adds multiple elements to the set

B) Removes multiple elements from the set

C) Checks if all elements are present in the set

A) has()

B) contains()

C) check()

A) Elements present in both sets

B) Elements present in the first set but not in the second set

C) Elements present in the second set but not in the first set

A) Using the combine method

B) Using the intersect method

C) Using the intersection method

A) isEmpty

B) isNotEmpty

C) empty

A) Using the delete method

B) Using the remove method

C) Using the discard method

A) Adds all elements to the set

B) Removes all elements from the set

C) Checks if the set is empty

A) Using the toList method

B) Using the toSet method

C) Using the toList property

A) forEach()

B) map()

C) apply()

A) Checks if the set is a subset of another set

B) Checks if all elements in one set are present in another set

C) Checks if the set contains any of the elements in another set

A) union()

B) merge()

C) combine()

A) Using curly braces {}

B) Using square brackets []

C) Using parentheses ()

1-B) A collection of unique elements

2-B) Using curly braces {}

3-A) add()

4-A) Adds multiple elements to the set

5-B) contains()

6-B) Elements present in the first set but not in the second set

7-C) Using the intersection method

8-A) isEmpty

9-B) Using the remove method

10-B) Removes all elements from the set

11-A) Using the toList method

12-A) forEach()

13-B) Checks if all elements in one set are present in another set

14-A) union()

15-A) Using curly braces {}

Main Content