How does LinkedHashMap work under the hood?
collections, dictionary, hashmap, java, oop
Solution
If you define `MyLinkedHashMap` under package `java.util`, it will compile;)
Because `HashMap.HashEntry` is package visibility.
PLUS:
I think the major thing puzzled you is LinkedHashMap.Entry vs HashMap.Entry. The point is LinkedHashMap.Entry is-a HashMap.Entry. Actually HashMap.table stores LinkedHashMap.Entry in LinkedHashMap.
Regarding to `recordAccess` and `recordRemoval`, they both override HashMap.Entry versions. You could find out the references both in LinkedHashMap and HashMap.
Merge comments here: You sample code is not same as `LinkedHashMap` implementation. See `LinkedHashMap.addEntry()` instead.
Problem
I read about LinkedHashMap and from the description (although very interesting) I couldn't understand how it actually does its job under the hood. As a side note, I know how a `HashMap` works underneath in Java. So I review the source and still can not figure out how it works. Perhaps I am not grasping something fundamental in OOP in this case so bear with me. To summarize the part that is confusing to me is the following: The `LinkedHashMap` delegates all the calls to its parent `HashMap`. Internally it overrides the `HashMap.Entry` to implement the various `recordAccess` and `recordRemoval` methods which seem to implement the logic of the `LinkedHashMap` But the actual `Entries` are inside the table of the base class i.e. the `HashMap` which instantiates a table of `HashMap.Entry` and not of `LinkedHashMap.Entry`. So I can't figure out how the various `recordAccess` and `recordRemove` etc are actually being called. So can anyone help me understand what's going on here? Am I correct to think that somehow the `LinkedHashedMap.Entry` is the type of table created by the `HashMap`? But how? UPDATE: My question is how do the `recordAccess` are being called. My experiment on this using a derived version of `HashMap` failed for the reason of Shengyuan Lu (+1) - My bad there UPDATE: The following which I tried is the same (I think) as what the `LinkedHashMap` is doing: ``` package delete; public class Base<T> { Entry<T>[] table; int idx = 0; @SuppressWarnings("unchecked") public Base(){ System.out.println("In base"); table = new Entry[10]; } public void add(T x){ table[idx] = new Entry(x); table[idx].doSomething(); } static class Entry<T>{ T value; Entry(T x){ this.value = x; System.out.println("Entry::Base"); } void doSomething(){ System.out.println("In Entry base, doing something"); } } } public class Derived<T> extends Base<T> { static class Entry<T> extends Base.Entry<T>{ Entry(T x) { super(x); System.out.println("In Entry derived"); } int val; @Override void doSomething() { System.out.println("In Entry derived doing something really smart!"); } } /** * @param args */ public static void main(String[] args) { Base<String> b = new Derived<String>(); b.add("Test string"); } } ``` But it prints: ``` In base Entry::Base In Entry base, doing something ``` So the derived `Entry` is never called. Is my example different somehow? I can't understand how this works for `LinkedHashMap`