The default 'List' constructor isn't available when null safety is enabled. Try using a list literal, 'List.filled' or 'List.generate'

Question

Why List() constructor is not accessible after Dart's null safety?

// Compile time error: 'List' is deprecated and shouldn't be used.
// The default 'List' constructor isn't available when null safety is enabled. 
// Try using a list literal, 'List.filled' or 'List.generate'.
List<int> foo = List(); 

However, you can still do:

List<int> foo = []; // No error

So, what's the difference between the two? Either both of them should show the error or none of them.

Solution 1

Short answer:

Instead of the pre-null-safety operations

var foo = List<int>();  // Now error
var bar = List<int>(n); // Now error
var baz = List<int>(0); // Now error

use the following:

var foo = <int>[];           // Always the recommended way.
var bar = List.filled(1, 0); // Not filled with `null`s.
var baz = List<int>.empty();

Long answer:

The List constructor had two uses:

• new List() to create an empty growable list, equivalent to [].
• new List(n) to create a fixed-length list of length n filled with null values

With null safety, the second use was unsound most of the time, and there was no good way to fix it. It's possible to force a type argument to be non-nullable, but List<T>(4) only works when T is nullable. There is no way to enforce that.

So, the List(n) mode needed to go (replaced by List.filled(n, value) which forces you to provide a fill-value). That left List(), which doesn't really carry its own weight. You can just use [] instead (and you should!), so it was decided to remove the constructor entirely - all uses of it was either unsafe or useless. (Also, it was a weird constructor already, because if we wanted to properly make it null safe, it would have an optional parameter with a non-nullable type and no default value.)

By removing it completely, it makes it possible to, potentially, introduce a new List constructor in the future, perhaps as a shorter alias for List.filled. One can hope.

Solution 2

Apart from what @lrn sir mentioned, you can also create a list using:

List<int> foo = List<int>.empty(growable: true); // []

Solution 3

This is because the the default List() element was deprecated how about you try using List.filled() element as shown below

void display() {
    var fixedList = new List<int>.filled(5, 0, growable: false);
    fixedList[0] = 0;
    fixedList[1] = 10;
    fixedList[2] = 20;
    fixedList[3] = 30;
    fixedList[4] = 40;
    print('Elements in the list are as follows: $fixedList');
  }
} 

While for the Growable Length List you can try doing as shown below:

void main() {
    var growableList = new List<int>.filled(0,0, growable:true);
    growableList = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90];
    print('The elements in the growable list include: $growableList');
  }

Comments

[iDecode]

I wish the same thing was mentioned in the official docs. Your answer is much more clear than someone who wrote the article of Understanding null safety describing why List() is removed.

[lrn]

That article does a very good job of describing what we do, and the primary reason why, but it would be overkill to go into all the details. The article is full of information, and avoiding overloading the reader is also important. If you take one thing away from that section, it should be "List constructor is no more", and that's all we can hope for. (Also, the recommendation to use [] instead of List() isn't new, dart.dev/guides/language/effective-dart/…, so the author probably didn't think it needed repeating.)

[iDecode]

Hi, "This is because the the default List() element was deprecated" -- which is why I wrote the question and for "how about you try using List.filled()", this is already provided by Lrn.

[jayjw]

The List.empty({bool growable = false}) constructor is also worth a mention. I landed here after some confusion around if the [] syntax creates a growable list (which it does, unless you are using the const empty list const [], which of course makes perfect sense but I had not thought through.)

[Lutaaya Huzaifah Idris]

Suppose it's a list of objects e.gList<OnDemandVideo>

[lrn]

Agree. The List.empty constructor is only needed for creating an empty non-growable or potentially non-growable list. For a growable list, you should just use a list literal.