If you subclass AbstractLinkedMap but not LinkEntry then you will not be able to access the protected fields. The entryXxx() methods on AbstractLinkedMap exist to provide the necessary access. 

 protected AbstractLinkedMap() 
{
        super();
}

Constructor only used in deserialization, do not use otherwise.

 protected AbstractLinkedMap(int initialCapacity) 
{
        super(initialCapacity);
}

Constructs a new, empty map with the specified initial capacity.

Parameters:

initialCapacity - the initial capacity

Throws:

IllegalArgumentException - if the initial capacity is less than one

 protected AbstractLinkedMap(Map map) 
{
        super(map);
}

Constructor copying elements from another map.

Parameters:

map - the map to copy

Throws:

NullPointerException - if the map is null

 protected AbstractLinkedMap(int initialCapacity,
    float loadFactor) 
{
        super(initialCapacity, loadFactor);
}

Constructs a new, empty map with the specified initial capacity and load factor.

Parameters:

initialCapacity - the initial capacity

loadFactor - the load factor

Throws:

IllegalArgumentException - if the initial capacity is less than one

IllegalArgumentException - if the load factor is less than zero

 protected AbstractLinkedMap(int initialCapacity,
    float loadFactor,
    int threshold) 
{
        super(initialCapacity, loadFactor, threshold);
}

Constructor which performs no validation on the passed in parameters.

Parameters:

initialCapacity - the initial capacity, must be a power of two

loadFactor - the load factor, must be > 0.0f and generally < 1.0f

threshold - the threshold, must be sensible

 protected  void addEntry(HashEntry entry,
    int hashIndex) 
{
        LinkEntry link = (LinkEntry) entry;
        link.after  = header;
        link.before = header.before;
        header.before.after = link;
        header.before = link;
        data[hashIndex] = entry;
}

Adds an entry into this map, maintaining insertion order.

This implementation adds the entry to the data storage table and to the end of the linked list.

 public  void clear() 
{
        // override to reset the linked list
        super.clear();
        header.before = header.after = header;
}

Clears the map, resetting the size to zero and nullifying references to avoid garbage collection issues.

 public boolean containsValue(Object value) 
{
        // override uses faster iterator
        if (value == null) {
            for (LinkEntry entry = header.after; entry != header; entry = entry.after) {
                if (entry.getValue() == null) {
                    return true;
                }
            }
        } else {
            for (LinkEntry entry = header.after; entry != header; entry = entry.after) {
                if (isEqualValue(value, entry.getValue())) {
                    return true;
                }
            }
        }
        return false;
}

Checks whether the map contains the specified value.

 protected HashEntry createEntry(HashEntry next,
    int hashCode,
    Object key,
    Object value) 
{
        return new LinkEntry(next, hashCode, key, value);
}

Creates an entry to store the data.

This implementation creates a new LinkEntry instance.

 protected Iterator createEntrySetIterator() 
{
        if (size() == 0) {
            return EmptyOrderedIterator.INSTANCE;
        }
        return new EntrySetIterator(this);
}

Creates an entry set iterator. Subclasses can override this to return iterators with different properties.

 protected Iterator createKeySetIterator() 
{
        if (size() == 0) {
            return EmptyOrderedIterator.INSTANCE;
        }
        return new KeySetIterator(this);
}

Creates a key set iterator. Subclasses can override this to return iterators with different properties.

 protected Iterator createValuesIterator() 
{
        if (size() == 0) {
            return EmptyOrderedIterator.INSTANCE;
        }
        return new ValuesIterator(this);
}

Creates a values iterator. Subclasses can override this to return iterators with different properties.

 protected AbstractLinkedMap.LinkEntry entryAfter(AbstractLinkedMap.LinkEntry entry) 
{
        return entry.after;
}

Gets the after field from a LinkEntry. Used in subclasses that have no visibility of the field.

 protected AbstractLinkedMap.LinkEntry entryBefore(AbstractLinkedMap.LinkEntry entry) 
{
        return entry.before;
}

Gets the before field from a LinkEntry. Used in subclasses that have no visibility of the field.

 public Object firstKey() 
{
        if (size == 0) {
            throw new NoSuchElementException("Map is empty");
        }
        return header.after.getKey();
}

Gets the first key in the map, which is the most recently inserted.

 protected AbstractLinkedMap.LinkEntry getEntry(int index) 
{
        if (index <  0) {
            throw new IndexOutOfBoundsException("Index " + index + " is less than zero");
        }
        if (index  >= size) {
            throw new IndexOutOfBoundsException("Index " + index + " is invalid for size " + size);
        }
        LinkEntry entry;
        if (index <  (size / 2)) {
            // Search forwards
            entry = header.after;
            for (int currentIndex = 0; currentIndex <  index; currentIndex++) {
                entry = entry.after;
            }
        } else {
            // Search backwards
            entry = header;
            for (int currentIndex = size; currentIndex  > index; currentIndex--) {
                entry = entry.before;
            }
        }
        return entry;
}

Gets the key at the specified index.

 protected  void init() 
{
        header = (LinkEntry) createEntry(null, -1, null, null);
        header.before = header.after = header;
}

Initialise this subclass during construction.

NOTE: As from v3.2 this method calls #createEntry(HashEntry, int, Object, Object) to create the map entry object.

 public Object lastKey() 
{
        if (size == 0) {
            throw new NoSuchElementException("Map is empty");
        }
        return header.before.getKey();
}

Gets the last key in the map, which is the first inserted.

 public MapIterator mapIterator() 
{
        if (size == 0) {
            return EmptyOrderedMapIterator.INSTANCE;
        }
        return new LinkMapIterator(this);
}

Gets an iterator over the map. Changes made to the iterator affect this map.

A MapIterator returns the keys in the map. It also provides convenient methods to get the key and value, and set the value. It avoids the need to create an entrySet/keySet/values object.

 public Object nextKey(Object key) 
{
        LinkEntry entry = (LinkEntry) getEntry(key);
        return (entry == null || entry.after == header ? null : entry.after.getKey());
}

Gets the next key in sequence.

 public OrderedMapIterator orderedMapIterator() 
{
        if (size == 0) {
            return EmptyOrderedMapIterator.INSTANCE;
        }
        return new LinkMapIterator(this);
}

Gets a bidirectional iterator over the map. Changes made to the iterator affect this map.

A MapIterator returns the keys in the map. It also provides convenient methods to get the key and value, and set the value. It avoids the need to create an entrySet/keySet/values object.

 public Object previousKey(Object key) 
{
        LinkEntry entry = (LinkEntry) getEntry(key);
        return (entry == null || entry.before == header ? null : entry.before.getKey());
}

Gets the previous key in sequence.

 protected  void removeEntry(HashEntry entry,
    int hashIndex,
    HashEntry previous) 
{
        LinkEntry link = (LinkEntry) entry;
        link.before.after = link.after;
        link.after.before = link.before;
        link.after = null;
        link.before = null;
        super.removeEntry(entry, hashIndex, previous);
}

Removes an entry from the map and the linked list.

This implementation removes the entry from the linked list chain, then calls the superclass implementation.