Clone a List, Map or Set in Dart

Question

Coming from a Java background: what is the recommended way to "clone" a Dart List, Map and Set?

Answer 1

Use of clone() in Java is tricky and questionable^1,2. Effectively, clone() is a copy constructor and for that, the Dart List, Map and Set types each have a named constructor named .from() that perform a shallow copy; e.g. given these declarations

  Map<String, int> numMoons, moreMoons;
  numMoons = const <String,int>{ 'Mars' : 2, 'Jupiter' : 27 };
  List<String> planets, morePlanets;

you can use .from() like this:

  moreMoons = new Map<String,int>.from(numMoons)
    ..addAll({'Saturn' : 53 });
  planets = new List<String>.from(numMoons.keys);
  morePlanets = new List<String>.from(planets)
    ..add('Pluto');

Note that List.from() more generally accepts an iterator rather than just a List.

For sake of completeness, I should mention that the dart:html Node class defines a clone() method.

---

¹ J. Bloch, "Effective Java" 2nd Ed., Item 11.
²B. Venners, "Josh Bloch on Design: Copy Constructor versus Cloning", 2002. Referenced from here³. Quote from the article:

If you've read the item about cloning in my book, especially if you read between the lines, you will know that I think clone is deeply broken. ---J.Bloch

³Dart Issue #6459, clone instance(object).

Answer 2

For lists and sets, I typically use

List<String> clone = []..addAll(originalList);

The caveat, as @kzhdev mentions, is that addAll() and from()

[Do] not really make a clone. They add a reference in the new Map/List/Set.

That's usually ok with me, but I would keep it in mind.

Answer 3

If you are using dart > 2.3.0, You can use spread operator something like:

List<int> a = [1,2,3];
List<int> b = [...a]; // copy of a

Answer 4

With the new version of dart cloning of a Map or List become quite easy. You can try this method for making a deep clone of List and Map.

For List

List a = ['x','y', 'z'];
List b = [...a];

For Maps

Map mapA = {"a":"b"};
Map mapB = {...mapA};

For Sets

Set setA = {1,2,3,};
Set setB = {...setA};

I hope someone find this helpful.

Answer 5

For deep copy (clone), you can use :

Map<String, dynamic> src = {'a': 123, 'b': 456};
Map<String, dynamic> copy = json.decode(json.encode(src));

but there may be some concerns about the performance.

Answer 6

This solution should work:

  List list1 = [1,2,3,4]; 

  List list2 = list1.map((element)=>element).toList();

It's for a list but should work the same for a map etc, remember to add to list if its a list at the end

Answer 7

Map.from() only works for 1D map.

To copy multi dimensional map without reference in dart use following method

    Map<keyType, valueType> copyDeepMap( Map<keyType, valueType> map )
    {
        Map<keyType, valueType> newMap = {};

        map.forEach
        (
            (key, value)
            {
                newMap[key] =( value is Map ) ? copyDeepMap(value) : value ;
            }
        );

        return newMap;
    }

Answer 8

Best solution for me:

List temp = {1,2,3,4}
List platforms = json.decode(json.encode(parent.platforms));

Answer 9

This was my solution. I hope it can help someone.

  factory Product.deepCopy(Product productToCopy) => new Product(
    productToCopy.id,
    productToCopy.title,
    productToCopy.description,
    productToCopy.price,
    productToCopy.imageUrl,
    productToCopy.isFavorite,
  );}

Answer 10

To copy Map<String, List> filtered;

 var filteredNewCopy = filtered.map((key, value) => MapEntry(key, [...value]));

Answer 11

There is no 100% bullet proof way of making an exact isolated copy, but the answer from Manish Dhruw is pretty good. However, it will only work for Maps containing simple variable types and nested Maps.

To extend it to also work with other common collections, such as List and Set, and combinations of them, you could use something like the code below.

You don't really need the DeepCopyable class, but it would be useful if you want to easily make your own classes "deep-copyable" with these functions.

abstract class DeepCopyable{
  T deepCopy<T>();
}

List<T> listDeepCopy<T>(List list){
  List<T> newList = List<T>();

  list.forEach((value) {
    newList.add(
      value is Map ? mapDeepCopy(value) :
      value is List ? listDeepCopy(value) :
      value is Set ? setDeepCopy(value) :
      value is DeepCopyable ? value.deepCopy() :
      value
    );
  });

  return newList;
}

Set<T> setDeepCopy<T>(Set s){
  Set<T> newSet = Set<T>();

  s.forEach((value) {
    newSet.add(
      value is Map ? mapDeepCopy(value) :
      value is List ? listDeepCopy(value) :
      value is Set ? setDeepCopy(value) :
      value is DeepCopyable ? value.deepCopy() :
      value
    );
  });

  return newSet;
}


Map<K,V> mapDeepCopy<K,V>(Map<K,V> map){
  Map<K,V> newMap = Map<K,V>();

  map.forEach((key, value){
    newMap[key] =
      value is Map ? mapDeepCopy(value) :
      value is List ? listDeepCopy(value) :
      value is Set ? setDeepCopy(value) :
      value is DeepCopyable ? value.deepCopy() :
      value;
  });

  return newMap;
}

As I mentioned, it's obviously still not 100% bullet proof - for example you will loose type information for nested collections.

Answer 12

The given answer is good, but be aware of the generate constructor which is helpful if you want to "grow" a fixed length list, e.g.:

List<String> list = new List<String>(5);
int depth = 0; // a variable to track what index we're using

...
depth++;
if (list.length <= depth) {
  list = new List<String>.generate(depth * 2,
      (int index) => index < depth ? list[index] : null,
      growable: false);
}