I’m confused by something. HashMap has a filterKey...

# announcements

[Travis Griggs]

I’m confused by something. HashMap has a filterKeys (among others) method. But they’re defined as Map interface things. It seems I then have to cast the result back to HashMap, e.g.

this.modifyRegistry { registry ->
registry.filterKeys { oid -> keepOIDs.contains(oid) } as HashMap
}

I don’t understand why it doesn’t know that registry is a HashMap<PlanID, Plan>. I’ve typed it that way everywhere. But without that as Hashmap I get warnings/errors.

I feel like I’m missing some piece of the puzzle that it wasn’t obvious/apparent to me to put the as Hashmap there.

[gian]

Usually when you apply this kind of transformations you are creating a new collection and you usually can’t assume that the return type will be the same as the original one

[gian]

What you can do instead of casting is to use the toMutableMap function

[gian]

The same goes for other types of collection

[diesieben07]

If you want a specific resulting collection, you can use the xxxTo methods, such as:

val result = myCollection.filterTo(HashMap()) { it > 5 }

[diesieben07]

(That's a stupid example I realize now, because collection and map... but you get the point :D)

[Travis Griggs]

No, .toMutableMap() does not work.

[Travis Griggs]

Screen Shot 2019-10-25 at 8.16.02 AM.png

[diesieben07]

Yes, toMutableMap will give you a generic MutableMap.

[diesieben07]

refer to my answer above.
However it is usually a good idea to code against interfaces (like Map, MutableMap, Collection, List, etc.) instead of implementations (like HashMap).

[gian]

yeah, usually there is no reason in directly exposing implementation types

[Travis Griggs]

At some point though, if I want to create an actual something, I can’t use an interface, can I? e.g.

val Registry = HashMap<PlanID, Plan>()

If I replace HashMap with Map, I get a no constructors error. As I then write methods around that, it doesn’t like it if I don’t specify HashMap

[diesieben07]

val registry: Map<PlanID, Plan> = HashMap()

[gian]

val registry: Map<PlanID, Plan> = mutableMapOf()

[diesieben07]

mutableMapOf will give you some map implementation, you don't know which.

[gian]

It depends if you actually need the hashmap or not

[diesieben07]

The only guarantee you get is "The returned map preserves the entry iteration order."

[diesieben07]

Which effectively means you get LinkedHashMap

[gian]

yeah, but it depends on the requirements

[gian]

maybe you don’t even need a MutableMap

[Travis Griggs]

I need a MutableMap in this case (I’m using [] and remove on it). But I could change those. But the the lightbulb is the declaring it as an interface, but creating it with a concrete type. Sort of a duh actually.

[Travis Griggs]

Allthough ironically, my original question method still complains because the registry in the original closure now passes a MutableMap, but the filterKeys returns a Map. So I’d have to do the toMutableMap anyway. Took me a few minutes, but I think I get the missing piece now. thanks