Dart Collections & Generics
7 questions foundWhat are the three main built in collection types in Dart, List, Set, and Map, and what makes each one uniquely suited for a different kind of data storage need?
Beginner A List stores an ordered collection of items where duplicates are fully allowed and each item can be accessed directly by its numeric index position, a Set stores an unordered collection where every single item must be unique, automatically removing any duplicate values, and a Map stores a collection of key value pairs, letting you efficiently look up a specific value using its associated unique key, and choosing the right one of these three collection types for a given situation depends entirely on whether you genuinely need ordering, uniqueness, or efficient key based lookup for your specific data.
List<String> fruits = ['apple', 'banana', 'apple']; // Duplicates allowed
Set<String> uniqueFruits = {'apple', 'banana'}; // No duplicates
Map<String, int> prices = {'apple': 1, 'banana': 2}; // Key-value pairs
Real-world example A shopping cart uses a List to maintain the exact order items were added, including the possibility of the same item being added multiple times, while a separate feature tracking unique visited product categories uses a Set specifically to automatically avoid duplicate category entries.
Common follow-ups: How do you efficiently check whether a specific item already exists within a Set versus within a List?;What is the time complexity difference between looking up a value in a Map compared to searching through a List?
Dart Language Basics & Syntax;Dart Null Safety
What are generics in Dart, and how does declaring a collection like List<String> let the Dart compiler catch type related mistakes before your code even runs?
Beginner Generics let you parameterize a class or a collection type with a specific type, such as declaring a List specifically intended to hold only String values as List<String>, and this lets the Dart compiler verify at compile time that only values of that exact expected type are ever actually added to that collection, immediately catching an accidental mistake, such as trying to add an integer to a list that was explicitly declared to hold only strings, well before that mistake could ever cause a genuine runtime error somewhere later in your actual running application.
List<String> names = ['Alex', 'Sarah'];
names.add(42); // Compile time error: an int cannot be assigned to a String list
Real-world example A developer accidentally attempts to add a numeric user ID directly into a list explicitly typed as List<String> intended for names, and the Dart compiler immediately catches this specific type mismatch mistake before the app is even run.
Common follow-ups: Can a generic type parameter itself be another generic type, such as a List of Lists?;What is the difference between using dynamic and using a specific generic type parameter?
Dart Null Safety;Dart Language Basics & Syntax
How do commonly used higher order collection methods, such as map, where, and reduce, let you transform and filter Dart collections in a clean, declarative style?
Intermediate Dart's collection types provide a rich set of built in higher order methods that let you transform and filter data in a clean, declarative style, including map, which applies a specific transformation function to every single item and returns a brand new collection of the transformed results, where, which returns only the specific items that satisfy a given condition, and reduce, which combines every item within a collection together into one single final value, and chaining these methods together often lets you express fairly complex data processing logic far more concisely and readably than writing the equivalent explicit manual loops yourself.
final total = orders
.where((order) => order.isCompleted)
.map((order) => order.total)
.reduce((a, b) => a + b);
Real-world example An order summary screen calculates the total revenue from only the completed orders by chaining where and map together to first filter and transform the relevant orders, then reduce to sum their individual totals, all within one single concise, readable expression.
Common follow-ups: What is the difference between reduce and fold, given they both seem to combine values together?;Do these higher order methods create an entirely new collection, or do they modify the original collection directly in place?
Dart Language Basics & Syntax;Flutter Performance Optimization
How do you create a custom generic class in Dart, and why would a generic class be preferable to writing several nearly identical, separate classes each hardcoded for a different specific type?
Intermediate A custom generic class lets you define a reusable class structure once, parameterized with a placeholder type that gets specified later whenever that class is actually used, such as building a generic Result class capable of representing either a successful value of any type or a failure error, and this avoids the need to write and separately maintain several nearly identical classes, each hardcoded for one specific different data type, since the exact same single generic class definition can correctly and safely work with many different concrete types.
class Result<T> {
final T? value;
final String? error;
Result.success(this.value) : error = null;
Result.failure(this.error) : value = null;
}
final userResult = Result<User>.success(fetchedUser);
Real-world example A networking layer defines a single generic Result class capable of representing either a successful response or a failure for any type of data being fetched, avoiding the need to write a separate, nearly duplicate result class for users, orders, and every other different type of data the app fetches.
Common follow-ups: How do you add a constraint restricting a generic type parameter to only certain kinds of types?;What is the difference between a generic class and a generic function in Dart?
Dart Language Basics & Syntax;Flutter App Architecture with Modular Feature Folders
What are unmodifiable and immutable collections in Dart, and why might you deliberately choose to use one instead of a regular mutable collection in certain parts of your code?
Intermediate An unmodifiable collection, created using a constructor such as List.unmodifiable, throws an error if any code ever attempts to modify it after its initial creation, such as adding or removing an item, and deliberately using unmodifiable collections in appropriate places, such as when exposing a private internal list publicly from a class, helps prevent unintended external modification of data that should genuinely remain fixed and protected, catching an accidental mutation mistake early with a clear error rather than allowing silent, unexpected changes to data elsewhere in a large codebase.
class ShoppingCart {
final List<String> _items = [];
List<String> get items => List.unmodifiable(_items);
}
Real-world example A ShoppingCart class exposes its internal items list only as an unmodifiable copy through its public getter, preventing external code from accidentally directly modifying the cart's actual internal contents without going through the class's own properly controlled methods.
Common follow-ups: What is the performance cost of creating an unmodifiable copy of a large collection?;How does Dart's const keyword relate to creating a fully immutable collection at compile time?
Dart Language Basics & Syntax;Flutter App Architecture with Modular Feature Folders
How do bounded type parameters, using the extends keyword within a generic class definition, let you constrain a generic type to only accept types that satisfy a specific requirement?
Advanced A bounded type parameter lets you restrict a generic class or function so that its type parameter must extend, meaning inherit from or implement, a specific class or interface, which lets you safely call methods defined on that required bound directly within your generic code, something that would not otherwise be possible with a completely unconstrained generic type parameter, since Dart cannot know in advance what methods an entirely arbitrary, unconstrained type might actually support.
class Repository<T extends Identifiable> {
T findById(String id, List<T> items) {
return items.firstWhere((item) => item.id == id);
}
}
Real-world example A generic Repository class constrains its type parameter to only accept types that implement an Identifiable interface, allowing it to safely call the id property directly within its own generic findById method, which would not be possible if the type parameter were left completely unconstrained.
Common follow-ups: What happens if you try to pass a type that does not satisfy the required bound?;Can a generic type parameter have more than one bound at the same time?
Flutter App Architecture with Modular Feature Folders;Dart Language Basics & Syntax
What are the performance and memory tradeoffs between using a List, a LinkedHashMap, and a HashSet in Dart when working with a genuinely very large collection of data?
Advanced A regular List provides fast, direct index based access but genuinely slow linear time lookups when you need to search for a specific value based on its content rather than its position, a HashSet provides very fast average case constant time lookups to check whether a specific value exists but does not preserve any particular meaningful ordering, and a LinkedHashMap combines efficient constant time key based lookup with also preserving the specific insertion order of its entries, and choosing the genuinely correct collection type for a very large dataset based on your specific access patterns, whether that means frequent searching, needing preserved ordering, or fast key based lookup, can meaningfully affect your application's real world performance at scale.
final visitedIds = HashSet<String>();
if (!visitedIds.contains(currentId)) {
visitedIds.add(currentId);
processItem(currentId);
}
Real-world example A large data deduplication process switches from repeatedly checking a growing List for already processed item identifiers to instead using a HashSet, dramatically improving performance once the underlying dataset grows into the hundreds of thousands of individual items.
Common follow-ups: What is the actual underlying time complexity difference between searching a List versus checking membership in a HashSet?;When would preserving insertion order, as a LinkedHashMap does, genuinely matter for a real application?
Flutter Performance Optimization;Dart Language Basics & Syntax