Creates an insertion-ordered hash-table based Map.
If equals is provided, it is used to compare the keys in the table with
new keys. If equals is omitted, the key's own Object.== is used
instead.
Similar, if hashCode is provided, it is used to produce a hash value
for keys in order to place them in the hash table. If it is omitted, the
key's own Object.hashCode is used.
If using methods like [], remove and containsKey together
with a custom equality and hashcode, an extra isValidKey function
can be supplied. This function is called before calling equals or
hashCode with an argument that may not be a K instance, and if the
call returns false, the key is assumed to not be in the set.
The isValidKey function defaults to just testing if the object is a
K instance.
Example:
new LinkedHashMap<int,int>(equals: (int a, int b) => (b - a) % 5 == 0,
hashCode: (int e) => e % 5)
This example map does not need an isValidKey function to be passed.
The default function accepts only int values, which can safely be
passed to both the equals and hashCode functions.
If neither equals, hashCode, nor isValidKey is provided,
the default isValidKey instead accepts all keys.
The default equality and hashcode operations are assumed to work on all
objects.
Likewise, if equals is identical, hashCode is identityHashCode
and isValidKey is omitted, the resulting map is identity based,
and the isValidKey defaults to accepting all keys.
Such a map can be created directly using LinkedHashMap.identity.
The used equals and hashCode method should always be consistent,
so that if equals(a, b) then hashCode(a) == hashCode(b). The hash
of an object, or what it compares equal to, should not change while the
object is in the table. If it does change, the result is unpredictable.
If you supply one of equals and hashCode,
you should generally also to supply the other.
Source
external factory LinkedHashMap(
{bool equals(K key1, K key2),
int hashCode(K key),
bool isValidKey(potentialKey)});