Dart Map

Mastering Dart Maps: Comprehensive Guide with Examples

Introduction:

In the world of Dart programming, maps are an essential data structure for organizing and manipulating key-value pairs efficiently. Understanding how to work with Dart maps is crucial for building robust applications. In this comprehensive guide, we’ll delve into Dart maps, exploring their creation, manipulation, and common operations with detailed examples.

In Dart, a map is a collection of key-value pairs where each key is unique. Dart’s map is represented by the Map class.

Here’s a basic example of how to use a map in Dart:

dart

void main() {
// Creating a map with initial values
Map<String, int> ages = {
'John': 30,
'Alice': 25,
'Bob': 35,
};

// Adding a new key-value pair
ages['Emily'] = 28;

// Accessing values using keys
print('John\'s age: ${ages['John']}');

// Iterating over the map
ages.forEach((key, value) {
print('$key is $value years old');
});

// Checking if a key exists
if (ages.containsKey('Alice')) {
print('Alice is in the map');
}

// Removing a key-value pair
ages.remove('Bob');

// Clearing the map
ages.clear();
}

In this example:

• We create a map called ages that maps names (keys of type String) to ages (values of type int).
• We add a new entry to the map using square bracket notation.
• We access values using their corresponding keys.
• We iterate over the map using the forEach method.
• We check if a key exists in the map using the containsKey method.
• We remove a key-value pair using the remove method.
• We clear the entire map using the clear method.

step by step How to creat Dart Map?

Creating a Dart map involves a few simple steps.

Here’s a step-by-step guide:

Import the Necessary Libraries (Optional):

Dart’s core libraries provide built-in support for maps, so you typically don’t need to import any additional libraries. However, if you’re working with Dart web or Flutter, you might import dart:core for basic functionality and dart:collection if you need to use specialized map implementations like LinkedHashMap.

dart

import 'dart:core'; // For basic functionality

Declare a Map Variable:

To create a map, declare a variable of type Map. You specify the types of the keys and values within angle brackets (<>).

For example, to create a map that maps strings to integers:

dart

Map<String, int> myMap;

Initialize the Map:

• You can initialize the map directly or assign it later.
• To initialize it with some initial key-value pairs, you can use curly braces {}.
• Inside the braces, you specify the key-value pairs separated by commas.

For example:

dart

Map<String, int> ages = {
'Omar': 20,
'Gogo': 17,
'Adam': 4,
};

This creates a map called ages with three entries: ‘John’ maps to 30, ‘Alice’ maps to 25, and ‘Bob’ maps to 35.

Add Entries to the Map (Optional):

You can add key-value pairs to the map using square bracket notation ([]). For example:

dart

ages['Abdo'] = 26;

This adds a new entry to the ages map, mapping ‘Abdo’ to 26.

Access Values from the Map:

You can access the values stored in the map using their corresponding keys. For example:

dart

int omarsAge = ages['Omar'];

This retrieves the value associated with the key ‘John’ from the ages map.

Iterate Over the Map:

You can iterate over the map to process each key-value pair. Dart provides various methods for iteration, such as forEach, for-in loop, or using map methods like keys, values, or entries.

Manipulate the Map:

You can manipulate the map by adding, removing, or updating key-value pairs as needed using methods like putIfAbsent, remove, clear, etc.

Check if a Key Exists (Optional):

You can check if a particular key exists in the map using the containsKey method.

Dispose the Map (Optional):

If you no longer need the map and want to free up memory, you can set the map variable to null or simply let it go out of scope.

That’s it! Following these steps, we can easily create and work with maps in Dart.

complete example with explanation

Here’s a complete example of creating a Dart map along with explanations for each step:

dart

void main() {
// Step 1: Declare a Map variable
// Declare a map variable with String keys and int values
Map<String, int> ages;

// Step 2: Initialize the Map
// Initialize the map with some initial key-value pairs
ages = {
'Omar': 20,
'Gogo': 17,
'Adam': 4,
};

// Step 3 (Optional): Add Entries to the Map
// Add a new entry to the map
ages['Elin'] = 4;

// Step 4: Access Values from the Map
// Access the value associated with the 'John' key
int omarsAge = ages['Omar'];
print('Omar\'s age: $omarssAge');

// Step 5: Iterate Over the Map
// Iterate over the map and print each key-value pair
ages.forEach((key, value) {
print('$key is $value years old');
});

// Step 6 (Optional): Manipulate the Map
// Remove a key-value pair from the map
ages.remove('Adam');

// Step 7 (Optional): Check if a Key Exists
// Check if a key exists in the map
if (ages.containsKey('Gogo')) {
print('Gogo is in the map');
}

// Step 8 (Optional): Dispose the Map
// Set the map variable to null to release memory
ages = null;
}

Explanation:

Declare a Map Variable (ages): We declare a map variable named ages with keys of type String and values of type int.

Initialize the Map: We initialize the ages map with some initial key-value pairs using curly braces {}.

Add Entries to the Map (Optional): We add a new entry to the map by assigning a value to a key using square bracket notation [].

Access Values from the Map: We access the value associated with the key ‘John’ and store it in a variable johnsAge. Then, we print it.

Iterate Over the Map: We iterate over the map using the forEach method to print each key-value pair.

Manipulate the Map (Optional): We remove a key-value pair from the map using the remove method.

Check if a Key Exists (Optional): We check if the key ‘Alice’ exists in the map using the containsKey method.

Dispose the Map (Optional): Finally, we set the map variable to null to release memory, though this step is optional as Dart automatically manages memory.

The ways to create Dart Map?

In Dart, there are several ways to create a map. Here are the main methods:

Using Map Literals:

Dart supports map literals, which are defined using curly braces {}. Inside the curly braces, you specify key-value pairs separated by commas.

dart

Map<String, int> ages = {
'Omar': 20,
'Gogo': 17,
'Adam': 4,
};

Using the Map() Constructor:

You can use the Map() constructor to create an empty map, and then add entries later.

dart

Map<String, int> ages = Map();
ages['Omar'] = 20;
ages['Gogo'] = 17;

Using fromIterable() Constructor:

Dart provides a constructor fromIterable() that creates a map from an iterable.

dart

List<String> names = ['Omar', 'Gogo', 'Adam'];
Map<String, int> ages = Map.fromIterable(names, key: (name) => name, value: (_) => 30);

This example creates a map where each name in the list names becomes a key, and the value associated with each key is set to 30.

Using fromEntries() Constructor (Dart 2.13 and later):

Dart 2.13 introduced the fromEntries() constructor, which creates a map from a list of key-value pairs (MapEntry objects).

dart

List<MapEntry<String, int>> entries = [
MapEntry('John', 30),
MapEntry('Alice', 25),
MapEntry('Bob', 35),
];
Map<String, int> ages = Map.fromEntries(entries);

Using the of() Constructor (Dart 2.15 and later):

Dart 2.15 introduced the of() constructor, which creates a map from an iterable of key-value pairs.

dart

Iterable<MapEntry<String, int>> entries = [
MapEntry('John', 30),
MapEntry('Alice', 25),
MapEntry('Bob', 35),
];
Map<String, int> ages = Map.of(Map<String, int>.fromEntries(entries));

This example is quite similar to fromEntries(), but of() offers a more concise way of creating a map from an iterable.

Choose the method that suits your use case and coding style best. Each method has its advantages depending on the specific scenario you’re dealing with.

complete example with explanation

Here’s a complete example demonstrating each way to create a Dart map along with explanations for each method:

dart

void main() {
// Method 1: Using Map Literals
// Creating a map with initial values using map literals
Map<String, int> agesMapLiteral = {
'John': 30,
'Alice': 25,
'Bob': 35,
};

// Method 2: Using the Map() constructor
// Creating an empty map and adding entries later
Map<String, int> agesMapConstructor = Map();
agesMapConstructor['John'] = 30;
agesMapConstructor['Alice'] = 25;

// Method 3: Using fromIterable() constructor
// Creating a map from an iterable (e.g., a list)
List<String> names = ['John', 'Alice', 'Bob'];
Map<String, int> agesFromIterable = Map.fromIterable(names,
key: (name) => name, value: (_) => 30);

// Method 4: Using fromEntries() constructor (Dart 2.13 and later)
// Creating a map from a list of key-value pairs (MapEntry objects)
List<MapEntry<String, int>> entries = [
MapEntry('John', 30),
MapEntry('Alice', 25),
MapEntry('Bob', 35),
];
Map<String, int> agesFromEntries = Map.fromEntries(entries);

// Method 5: Using the of() constructor (Dart 2.15 and later)
// Creating a map from an iterable of key-value pairs
Iterable<MapEntry<String, int>> entriesIterable = [
MapEntry('John', 30),
MapEntry('Alice', 25),
MapEntry('Bob', 35),
];
Map<String, int> agesFromOf = Map.of(Map<String, int>.fromEntries(entriesIterable));

// Printing out each map
print('Method 1: Using Map Literals');
printMap(agesMapLiteral);
print('Method 2: Using the Map() constructor');
printMap(agesMapConstructor);
print('Method 3: Using fromIterable() constructor');
printMap(agesFromIterable);
print('Method 4: Using fromEntries() constructor');
printMap(agesFromEntries);
print('Method 5: Using the of() constructor');
printMap(agesFromOf);
}

// Function to print out the contents of a map
void printMap(Map<String, int> map) {
map.forEach((key, value) {
print('$key: $value');
});
print('\n');
}

Explanation:

• Method 1: Using Map Literals
• We directly create a map with initial key-value pairs using curly braces {}.
  Method 2: Using the Map() constructor
• We create an empty map using the Map() constructor and then add entries to it using square bracket notation.
  Method 3: Using fromIterable() constructor
• We create a list of keys (names) and then use the fromIterable() constructor to create a map where each key is mapped to a default value of 30.
  Method 4: Using fromEntries() constructor (Dart 2.13 and later)
• We create a list of MapEntry objects and then use the fromEntries() constructor to create a map from these entries.
  Method 5: Using the of() constructor (Dart 2.15 and later)
• We create an iterable of key-value pairs (entriesIterable), convert it to a map using fromEntries(), and then use the of() constructor to create a new map from it.
  Finally, we define a function printMap() to print out the contents of each map for demonstration purposes.

All methods of Dart Map with explanation

Here are all the methods of creating a Dart map, along with explanations for each method:

1. Using Map Literals:

Explanation: Dart supports map literals, which allow you to define a map with initial key-value pairs using curly braces {}.
dart

Map<String, int> ages = {
'John': 30,
'Alice': 25,
'Bob': 35,
};

2. Using the Map() Constructor:

Explanation: Dart provides a constructor Map() to create an empty map, which you can populate with entries later using square bracket notation [].
dart

Map<String, int> ages = Map();
ages['John'] = 30;
ages['Alice'] = 25;

3. Using fromIterable() Constructor:

Explanation: This constructor creates a map from an iterable (e.g., a list). It requires two functions: one to extract keys and another to extract values from each element in the iterable.
dart

List<String> names = ['John', 'Alice', 'Bob'];
Map<String, int> ages = Map.fromIterable(names,
key: (name) => name, value: (_) => 30);

4. Using fromEntries() Constructor (Dart 2.13 and later):

Explanation: Dart 2.13 introduced the fromEntries() constructor, which creates a map from a list of key-value pairs (MapEntry objects).
dart

List<MapEntry<String, int>> entries = [
MapEntry('John', 30),
MapEntry('Alice', 25),
MapEntry('Bob', 35),
];
Map<String, int> ages = Map.fromEntries(entries);

5. Using the of() Constructor (Dart 2.15 and later):

Explanation: Dart 2.15 introduced the of() constructor, which creates a map from an iterable of key-value pairs.
dart

Iterable<MapEntry<String, int>> entries = [
MapEntry('John', 30),
MapEntry('Alice', 25),
MapEntry('Bob', 35),
];
Map<String, int> ages = Map.of(Map<String, int>.fromEntries(entries));

Each method has its advantages depending on your specific use case. Choose the one that suits your scenario best in terms of readability, performance, and code maintainability.

Operations and methods that are used with Dart Map 

Dart’s Map class provides a variety of operations and methods to manipulate and work with maps. Here are some of the most commonly used operations and methods along with explanations for each:

Operations:

Insertion: Adding new key-value pairs to the map.
Access: Retrieving values associated with specific keys.
Deletion: Removing key-value pairs from the map.
Iteration: Iterating over the map to process each key-value pair.
Checking: Checking if a key exists in the map.
Updating: Modifying the value associated with a key.

Dart Map Methods:

[] Operator:

Usage: map[key]
Explanation: Accesses the value associated with the specified key in the map. If the key is not present, it returns null.

putIfAbsent() Method:

Usage: map.putIfAbsent(key, () => value)
Explanation: Adds a new key-value pair to the map if the key is not already present. If the key exists, it returns the existing value; otherwise, it inserts the key with the specified value.

remove() Method:

Usage: map.remove(key)
Explanation: Removes the entry associated with the specified key from the map if it exists.

clear() Method:

Usage: map.clear()
Explanation: Removes all key-value pairs from the map, leaving it empty.

containsKey() Method:

Usage: map.containsKey(key)
Explanation: Returns true if the map contains the specified key; otherwise, returns false.

forEach() Method:

Usage: map.forEach((key, value) { /* your logic */ })
Explanation: Iterates over each key-value pair in the map and applies the provided function to each pair.

keys Property:

Usage: map.keys
Explanation: Returns an iterable containing all the keys in the map.

values Property:

Usage: map.values
Explanation: Returns an iterable containing all the values in the map.

length Property:

Usage: map.length
Explanation: Returns the number of key-value pairs in the map.

isEmpty Property:

Usage: map.isEmpty
Explanation: Returns true if the map is empty; otherwise, returns false.

isNotEmpty Property:

Usage: map.isNotEmpty
Explanation: Returns true if the map is not empty; otherwise, returns false.
These are some of the fundamental operations and methods available for working with Dart maps. They provide the necessary functionality to manipulate, access, and iterate over key-value pairs efficiently.

Operations of Operations:complete example with explanations

Let’s create a complete example demonstrating various operations and methods used with Dart maps, along with explanations for each:

dart

void main() {
// Creating a map with initial values
Map<String, int> ages = {
'John': 30,
'Alice': 25,
'Bob': 35,
};

// 1. Insertion Operation: Adding a new key-value pair
ages['Emily'] = 28;

// 2. Access Operation: Retrieving a value using a key
int johnsAge = ages['John'];
print('John\'s age: $johnsAge');

// 3. Deletion Operation: Removing a key-value pair
ages.remove('Bob');

// 4. Iteration Operation: Iterating over the map
print('Iterating over the map:');
ages.forEach((key, value) {
print('$key is $value years old');
});

// 5. Checking Operation: Checking if a key exists
if (ages.containsKey('Alice')) {
print('Alice is in the map');
} else {
print('Alice is not in the map');
}

// 6. Updating Operation: Modifying the value associated with a key
ages['John'] = 31; // John's birthday
print('John\'s age after update: ${ages['John']}');

// 7. Other Methods: length, isEmpty, isNotEmpty
print('Number of entries in the map: ${ages.length}');
print('Is the map empty? ${ages.isEmpty ? 'Yes' : 'No'}');
print('Is the map not empty? ${ages.isNotEmpty ? 'Yes' : 'No'}');
}

Explanation:

Insertion Operation: We add a new entry to the ages map by assigning a value to a new key (‘Emily’) using square bracket notation [].

Access Operation: We retrieve the value associated with the key ‘John’ and store it in the variable johnsAge. Then, we print it.

Deletion Operation: We remove the entry associated with the key ‘Bob’ from the ages map using the remove() method.

Iteration Operation: We iterate over the ages map using the forEach() method and print each key-value pair.

Checking Operation: We check if the key ‘Alice’ exists in the ages map using the containsKey() method.

Updating Operation: We update the value associated with the key ‘John’ to reflect his new age by assigning a new value to the existing key.

Other Methods: We demonstrate the usage of other methods like length, isEmpty, and isNotEmpty to get information about the map’s size and whether it’s empty or not.

All Methods that are used with dart map with code examples

Certainly! Below are the explanations and code examples for each of the commonly used methods with Dart maps:

1. [] Operator:

Usage: map[key]
Explanation: Accesses the value associated with the specified key in the map. If the key is not present, it returns null.

dart

Map<String, int> ages = {'John': 30, 'Alice': 25};
int johnsAge = ages['John']; // accessing value using key
print('John\'s age: $johnsAge'); // Output: John's age: 30

2. putIfAbsent() Method:

Usage: map.putIfAbsent(key, () => value)
Explanation: Adds a new key-value pair to the map if the key is not already present. If the key exists, it returns the existing value; otherwise, it inserts the key with the specified value.
dart

Map<String, int> ages = {'John': 30, 'Alice': 25};
int bobsAge = ages.putIfAbsent('Bob', () => 35); // Adding new key-value pair
print('Bob\'s age: $bobsAge'); // Output: Bob's age: 35

3. remove() Method:

Usage: map.remove(key)
Explanation: Removes the entry associated with the specified key from the map if it exists.
dart

Map<String, int> ages = {'John': 30, 'Alice': 25};
ages.remove('Alice'); // Removing a key-value pair
print(ages); // Output: {John: 30}

4. clear() Method:

Usage: map.clear()
Explanation: Removes all key-value pairs from the map, leaving it empty.
dart

Map<String, int> ages = {'John': 30, 'Alice': 25};
ages.clear(); // Clearing the map
print(ages.isEmpty); // Output: true

5. containsKey() Method:

Usage: map.containsKey(key)
Explanation: Returns true if the map contains the specified key; otherwise, returns false.
dart

Map<String, int> ages = {'John': 30, 'Alice': 25};
bool containsJohn = ages.containsKey('John'); // Checking if key exists
print('Contains John: $containsJohn'); // Output: Contains John: true

6. forEach() Method:

Usage: map.forEach((key, value) { /* your logic */ })
Explanation: Iterates over each key-value pair in the map and applies the provided function to each pair.
dart

Map<String, int> ages = {'John': 30, 'Alice': 25};
ages.forEach((key, value) {
print('$key is $value years old');
});
// Output:
// John is 30 years old
// Alice is 25 years old

7. keys Property:

Usage: map.keys
Explanation: Returns an iterable containing all the keys in the map.
dart

Map<String, int> ages = {'John': 30, 'Alice': 25};
Iterable<String> keys = ages.keys;
print(keys); // Output: (John, Alice)

8. values Property:

Usage: map.values
Explanation: Returns an iterable containing all the values in the map.
dart

Map<String, int> ages = {'John': 30, 'Alice': 25};
Iterable<int> values = ages.values;
print(values); // Output: (30, 25)

9. length Property:

Usage: map.length
Explanation: Returns the number of key-value pairs in the map.
dart

Map<String, int> ages = {'John': 30, 'Alice': 25};
int mapLength = ages.length;
print(mapLength); // Output: 2

10. isEmpty Property:

Usage: map.isEmpty
Explanation: Returns true if the map is empty; otherwise, returns false.
dart

Map<String, int> ages = {};
bool empty = ages.isEmpty;
print(empty); // Output: true

11. isNotEmpty Property:

Usage: map.isNotEmpty
Explanation: Returns true if the map is not empty; otherwise, returns false.
dart

Map<String, int> ages = {'John': 30, 'Alice': 25};
bool notEmpty = ages.isNotEmpty;
print(notEmpty); // Output: true

These methods and properties provide essential functionality for working with Dart maps efficiently.

An application abou Dart map with explanations

•  Let’s create a simple Dart console application that demonstrates the use of Dart maps.
• In this application, we’ll simulate a contacts list where each contact has a name and a phone number.
• We’ll perform operations such as adding a new contact, searching for a contact by name, deleting a contact, and listing all contacts.
• I’ll provide explanations for each part of the code.

dart

import 'dart:io';

void main() {
// Create an empty map to store contacts (name -> phone number)
Map<String, String> contacts = {};

// Main loop of the application
while (true) {
print('\nWelcome to the Contacts App!');
print('1. Add a contact');
print('2. Search for a contact');
print('3. Delete a contact');
print('4. List all contacts');
print('5. Exit');

// Prompt the for their choice
stdout.write('Enter your choice: ');
String choice = stdin.readLineSync()!;

switch (choice) {
case '1':
addContact(contacts);
break;
case '2':
searchContact(contacts);
break;
case '3':
deleteContact(contacts);
break;
case '4':
listContacts(contacts);
break;
case '5':
print('Exiting the Contacts App. Goodbye!');
return;
default:
print('Invalid choice. Please try again.');
}
}
}

// Function to add a new contact
void addContact(Map<String, String> contacts) {
stdout.write('Enter the name of the contact: ');
String name = stdin.readLineSync()!;
stdout.write('Enter the phone number: ');
String phoneNumber = stdin.readLineSync()!;
contacts[name] = phoneNumber;
print('Contact added successfully!');
}

// Function to search for a contact by name
void searchContact(Map<String, String> contacts) {
stdout.write('Enter the name of the contact to search: ');
String name = stdin.readLineSync()!;
if (contacts.containsKey(name)) {
print('Phone number for $name: ${contacts[name]}');
} else {
print('Contact not found!');
}
}

// Function to delete a contact by name
void deleteContact(Map<String, String> contacts) {
stdout.write('Enter the name of the contact to delete: ');
String name = stdin.readLineSync()!;
if (contacts.containsKey(name)) {
contacts.remove(name);
print('Contact deleted successfully!');
} else {
print('Contact not found!');
}
}

// Function to list all contacts
void listContacts(Map<String, String> contacts) {
if (contacts.isEmpty) {
print('No contacts found.');
} else {
print('List of Contacts:');
contacts.forEach((name, phoneNumber) {
print('$name: $phoneNumber');
});
}
}

Explanation:

• We start by importing the dart:io library to handle input and output operations.
• We create a main() function as the entry point of our application.
• Inside the main() function, we create an empty map called contacts to store contacts’ names as keys and their corresponding phone numbers as values.
• We use a while loop to repeatedly display a menu of options and execute the ‘s chosen operation until the chooses to exit the application.
• We define four functions:
• addContact(): Prompts the to enter a contact’s name and phone number and adds the contact to the contacts map.
• searchContact(): Prompts the to enter a contact’s name and searches for the contact in the contacts map. If found, it displays the contact’s phone number.
• deleteContact(): Prompts the to enter a contact’s name and deletes the contact from the contacts map if it exists.
• listContacts(): Lists all contacts stored in the contacts map.
• Each function interacts with the via standard input and output operations using stdin.readLineSync() and stdout.write().
• We call the appropriate function based on the ‘s choice using a switch statement.
• This application demonstrates basic usage of Dart maps and provides a simple interface for managing a contacts list.

Quiz about this lesson :15 questions with explanations

• Here’s a quiz based on the lesson about Dart maps. Each question is followed by four options, labeled (A), (B), (C), and (D), and only one option is correct.
• After each question, there is an explanation of the correct answer.

1-What is a Dart map?

(A) A collection of elements sorted by insertion order.
(B) A collection of key-value pairs where each key is unique.
(C) A collection of elements accessed by index.
(D) A collection of elements that allows duplicate values.

2-Which Dart library do you need to import to work with input and output operations?

(A) dart:collection
(B) dart:convert
(C) dart:io
(D) dart:async

3-Which method adds a new key-value pair to a Dart map if the key is not already present?

(A) put()
(B) add()
(C) putIfAbsent()
(D) insert()

4-What does the remove() method do in Dart maps?

(A) Removes the first element from the map.
(B) Removes the last element from the map.
(C) Removes the entry associated with the specified key from the map.
(D) Removes all elements from the map.

5-Which property returns an iterable containing all the keys in a Dart map?

(A) keys
(B) values
(C) length
(D) isEmpty

6-How do you access the value associated with a specific key in a Dart map?

(A) Using the value() method
(B) Using square bracket notation []
(C) Using the getValue() method
(D) Using the getValueForKey() method

7-Which method is used to iterate over each key-value pair in a Dart map?

(A) mapEach()
(B) forEach()
(C) iterate()
(D) map()

8-What does the length property of a Dart map return?

(A) The number of key-value pairs in the map.
(B) The sum of all values in the map.
(C) The total number of keys in the map.
(D) The total number of values in the map.

9-What does the isEmpty property of a Dart map return?

(A) true if the map has no keys.
(B) true if the map has no values.
(C) true if the map is empty (has no key-value pairs).
(D) true if the map has no null values.

10-Which Dart constructor creates an empty map?

(A) Map.empty()
(B) Map()
(C) Map.create()
(D) Map.emptyMap()

11-What does the containsKey() method of a Dart map do?

(A) Checks if a key exists in the map.
(B) Checks if a value exists in the map.
(C) Checks if a specific key-value pair exists in the map.
(D) Checks if the map is empty.

12-Which Dart method is used to clear all key-value pairs from a map?

(A) deleteAll()
(B) clear()
(C) removeAll()
(D) empty()

13-Which Dart method is used to add multiple entries to a map from a list of key-value pairs?

(A) addEntries()
(B) addAll()
(C) insertEntries()
(D) fromEntries()

14-Which Dart method is used to update the value associated with a key in a map?

(A) updateValue()
(B) modifyValue()
(C) setValue()
(D) update()

15-Which Dart method is used to remove a specific key-value pair from a map?

(A) delete()
(B) removeEntry()
(C) removeKey()
(D) remove()

Explanation:

1-(B) A Dart map is a collection of key-value pairs where each key is unique.
2-(C) To handle input and output operations in Dart, you need to import the dart:io library.
3-(C) The putIfAbsent() method adds a new key-value pair to a map if the key is not already present.
4-(C) The remove() method removes the entry associated with the specified key from the map.
5-(A) The keys property returns an iterable containing all the keys in a map.
6-(B) You access the value associated with a specific key in a map using square bracket notation [].
7-(B) The forEach() method is used to iterate over each key-value pair in a map.
8-(A) The length property of a Dart map returns the number of key-value pairs in the map.
9-(C) The isEmpty property of a Dart map returns true if the map is empty (has no key-value pairs).
10-(B) The Map() constructor creates an empty map.
11-(A) The containsKey() method of a Dart map checks if a key exists in the map.
12-(B) The clear() method is used to clear all key-value pairs from a map.
13-(D) The fromEntries() method is used to add multiple entries to a map from a list of key-value pairs.
14-(D) You use the update() method to update the