Navigable Map - Sorted Map yet un-ordered

• Hi everyone please help, I discovered the NavigableMap today and initially it worked for me until I did the following.
• When I populate the NavigableMap, notice from the end of the string value, I have added the values 1-4 and then 5.
• The string layout is for example "23816012269<1>", the last value <#> makes this unique because I am using it later in the code.
• All values up until 4 are duplicates (23816012269) , then 23806012269<5> is a new value prefixed with a different string/number and I will continue with new duplicates (suffixed with the next sequence <5> <#> number etc).
• The problem is, when I populate the NavigableMap in the order that you see below, it puts ("238060122695",...) at the first entry of the NavigableMap, even though this was added to the NavigableMap very last.
• Now when I use the NavigableMap.firstEntry().getKey() it reads "238060122695" as the first entry.
• I need to read 238160122691 as the first entry because this was added to the map as the first entry.
• Delving into the string value I know that 2380 comes before 2381, regardless, why does it treat it as the first entry when I added it last, is it because of the SortedMap interface that does this.? How do I avoid

This is code in the order being executed:

NavigableMap.put("238160122691", arrayListValue);

NavigableMap.put("238160122692", arrayListValue);

NavigableMap.put("238160122693", arrayListValue);

NavigableMap.put("238160122694", arrayListValue);

NavigableMap.put("238060122695", arrayListValue);

> Delving into the string value I know that 2380 comes before 2381, regardless, why does it treat it as the first entry when I added it last, is it because of the SortedMap interface that does this?

There seems to be a misunderstanding of what NavigableMap and its implementing classing like TreeMap are doing. They do not sort the elements in order of insertion, but by their natural order (i.e. how they compareTo each other), or given another Comparator.

> How do I avoid?

Well, you could wrap your string keys into a data structure that also has a number showing when it was inserted into the map, and provide a Comparator or compareTo method that sorts by that number. But more likely, NavigableMap is just not the right data structure for you. Have you considered just using a List or Queue, or maybe a LinkedHashMap as suggested in comments.

A NavigableMap is sorted:

> A SortedMap extended with navigation methods returning the closest matches for given search targets. [...]
A NavigableMap may be accessed and traversed in either ascending or descending key order.

If you want entries to be in insertion order, use a LinkedHashMap:

> Hash table and linked list implementation of the Map interface, with predictable iteration order. This implementation differs from HashMap in that it maintains a doubly-linked list running through all of its entries. This linked list defines the iteration ordering, which is normally the order in which keys were inserted into the map (insertion-order).

Thank you All, I have moved back to the LinkedList as suggested by everyone.

I then found the use of the ListIterator to find the the next entry and stored that in a variable to compare to the next Iteration.

ListIterator<Map.Entry<String, ArrayList<DataModel>>> listIterator = new LinkedList(myHashMap.entrySet()).listIterator();


 String previousk, nextk = null;
 Boolean entered = false;

    while (listIterator.hasNext())
    {
        if(entered){
            previousk = nextk.substring(0,12);
            if(previousk != nextk.substring(0,12)){
                *Set the flag here to be used*
            }
        }
        nextk = listIterator.next().getKey();
        entered = true;
        System.out.println(nextk);
    }