In this article, we will discuss NavigableMap interface with all its important method

1. Key points about NavigableMap:

• NavigableMap doesn’t allow duplicate keys
• Stores key-value pairs based on some sorting-order
• Sorting-order could be either natural-ordering or customized-ordering
• Provides useful methods for navigation purposes
• TreeMap class is implementation of NavigableMap

2. NavigableMap interface:

• NavigableMap interface is a sub-interface of SortedMap interface (i.e.; NavigableMap extends SortedMap)
• To represent a group of key-value pairs as a single unit/entity, where duplicates keys aren’t allowed and keys are stored according to some sorting-order
• It allows only unique keys to be inserted
• Stores key-value pairs in sorting order on the basis of keys only, not values
• NavigableMap interface defines more specific methods for navigation purposes, in addition to inherited methods from Map/SortedMap interfaces
• This is introduced in Java 1.6 version for navigation support to TreeMap class
• Present in java.util package and extends java.util.SortedMap interface

Source: Team BenchResources.Net

3. NavigableMap interface method:

4. Example to understand NavigableMap specific methods

• NavigableMap = [10-Alpha, 20-Beta, 30-Gamma, 40-delta, 50-epsilon, 60-lambda, 70-mu];
• floorKey(30) = 30-Gamma
• lowerKey(30) = 20-Beta
• ceilingKey(40) = 40-delta
• higherKey(40) = 50-epsilon
• pollFirstEntry() = 10-Alpha
• pollLastEntry() = 70-mu
• descendingMap() = [70-mu, 60-lambda, 50-epsilon, 40-delta, 30-Gamma, 20-Beta, 10-Alpha];

5. NavigableMap example

NavigableMapMethods.java

package in.bench.resources.java.collection;

import java.util.NavigableMap;
import java.util.TreeMap;

public class NavigableMapMethods {

	public static void main(String[] args) {

		// creating NavigableMap reference and TreeMap object
		NavigableMap<Integer, String> nm = new TreeMap<Integer, String>();

		// adding key-value pairs to SortedMap/TreeMap object
		nm.put(3, "Yahoo");
		nm.put(4, "Amazon");
		nm.put(7, "Twiter");
		nm.put(1, "Google");
		nm.put(5, "Reddit");
		nm.put(6, "LinkedIn");
		nm.put(2, "Facebook");

		// printing according to natural ordering
		System.out.println("Elements will be Sorted"
				+ " acc to Natural ordering:\n");
		System.out.println(nm);

		// floorKey and lowerKey methods
		System.out.println("\nfloorKey(3)  : " + nm.floorKey(3));
		System.out.println("\nlowerKey(3)  : " + nm.lowerKey(3));

		// ceilingKey and higherKey methods
		System.out.println("\nceilingKey(4)  : " + nm.ceilingKey(4));
		System.out.println("\nhigherKey(5)  : " + nm.higherKey(5));

		// pollFirstEntry method
		System.out.println("\npollFirstEntry() : " + nm.pollFirstEntry());
		System.out.println("NavigableMap after polling First Entry : "
				+ nm);

		// pollLastEntry method
		System.out.println("\npollLastEntry() : " + nm.pollLastEntry());
		System.out.println("NavigableMap after polling Last Entry : "
				+ nm);

		// descendingMap in descending or reverse order
		System.out.println("\nNavigableMap in descending order : "
				+ nm.descendingMap());
	}
}

Output:

Elements will be Sorted acc to Natural ordering:

{1=Google, 2=Facebook, 3=Yahoo, 4=Amazon, 5=Reddit, 6=LinkedIn, 7=Twiter}

floorKey(3)  : 3

lowerKey(3)  : 2

ceilingKey(4)  : 4

higherKey(5)  : 6

pollFirstEntry() : 1=Google
NavigableMap after polling First Entry : {2=Facebook, 3=Yahoo, 4=Amazon,
5=Reddit, 6=LinkedIn, 7=Twiter}

pollLastEntry() : 7=Twiter
NavigableMap after polling Last Entry : {2=Facebook, 3=Yahoo, 4=Amazon,
5=Reddit, 6=LinkedIn}

NavigableMap in descending order : {6=LinkedIn, 5=Reddit, 4=Amazon,
3=Yahoo, 2=Facebook}

Note: All methods of NavigableMap is non-synchronized

Q) How to make Navigable Map synchronized ?

• It can be easily converted into synchronized NavigableMap
• Using utility method synchronizedMap(nm); of java.util.Collections class
• Read Java – How to get synchronized version of Map ? for more details with example

Map map= Collections.synchronizedMap(nm);

6. Class that implements NavigableMap interface

• TreeMap implements NavigableMap interface

7. Factors to consider while discussing any collection class

We should consider below factors while discussing any implementation class of collection framework or for that matter Map interface,

• Underlying data structure
• Duplicates are allowed or Not
• Insertion order is maintained or Not
• Whether NULL insertion is possible or Not
• If possible, how many NULL values can be inserted
• Whether collection class provide sorting, by default
• Is there any way to apply customized sorting
• Performance, while dealing with retrieval or manipulation (addition/deletion)
• By default, all methods are synchronized or Not

Related Articles:

• Map interface
• Entry interface
• HashMap class
• LinkedHashMap class
• IdentityHashMap class
• WeakHashMap class
• SortedMap interface
• NavigableMap interface
• TreeMap class
• Hashtable class
• HashMap vs LinkedHashMap
• HashMap v/s LinkedHashMap v/s TreeMap
• HashMap v/s HashSet
• HashMap v/s Hashtable
• Properties class

References:

• https://docs.oracle.com/javase/tutorial/collections/intro/
• https://docs.oracle.com/javase/tutorial/collections/interfaces/collection.html
• https://docs.oracle.com/javase/7/docs/api/java/util/Collection.html
• https://docs.oracle.com/javase/7/docs/api/java/util/Map.html
• https://docs.oracle.com/javase/7/docs/api/java/util/Map.Entry.html
• https://docs.oracle.com/javase/tutorial/collections/interfaces/map.html
• https://docs.oracle.com/javase/7/docs/api/java/util/SortedMap.html
• https://docs.oracle.com/javase/tutorial/collections/interfaces/sorted-map.html
• https://docs.oracle.com/javase/7/docs/api/java/util/NavigableMap.html

Happy Coding !!
Happy Learning !!