NavigableSet in Java 6.0

NavigableSet API is included in the SCJP 6.0 certification exam. This article explains few important methods with simple example program. NavigableSet is the subinterface of SortedSet. This interface defines methods for finding the element in a list. For example lower() method used for finding the element which is less than the given value. Look into the following example:

package NavigableTutorial.net;

import java.util.ArrayList;
import java.util.List;
import java.util.NavigableSet;
import java.util.TreeSet;

public class NavigableSetTutorial1 {
    public static void main(String args[]){
        List list = new ArrayList();
        list.add(3);
        list.add(4);
        list.add(1);
        list.add(8);
        list.add(7);
        list.add(10);
       
        NavigableSet navigableSet = new TreeSet(list);
        System.out.println(navigableSet.lower(8));
        System.out.println(navigableSet.higher(8));
       
    }
}


Output:
7
10

In the above code, NavigableSet.lower() method is used for reteriving the value which is less than '8' in the list. Same way NavigableSet.higher() is used for reteriving the value greater than '8' in the list.

Java 6 - NavigableSet -headSet and tailSet Example Java Collections Framework

The below example explains the headSet and tailSet methods of the NavigableSet.

package examples;

import java.util.NavigableSet;
import java.util.TreeSet;
public class NavigableSetExample {

public static void main(String[] args) {
NavigableSet set = new TreeSet();
// Add elements in to the Navigable Set
set.add(1);
set.add(2);
set.add(3);
System.out.println(set);

// Head Set
System.out.println("Head Set :" + set.headSet(2));
System.out.println("Head Set including given integer: "+ set.headSet(2, true));

// Tail Set
System.out.println("Tail Set" + set.tailSet(2));
System.out.println("Tail Set including given integer: " + set.tailSet(2, false));
}

}

[1, 2, 3]
Head Set :[1]
Head Set including given integer: [1, 2]
Tail Set[2, 3]
Tail Set including given integer: [3]

NavigableSet - pollFirst and pollLast example Java Collections

pollFirst(), pollLast() methods of NavigableSet can be used to remove first and last element of the Set respectively. The below program explains the pollFirst() and pollLast()


package examples;

import java.util.NavigableSet;
import java.util.TreeSet;

public class NavigableSetExample {

public static void main(String args[]){
NavigableSet navigableSet = new TreeSet();

navigableSet.add(1);
navigableSet.add(2);

System.out.println("Set : " + navigableSet);

navigableSet.pollFirst();

System.out.println("Set After pollFirst " + navigableSet);

navigableSet.add(3);
navigableSet.add(4);

System.out.println("Set " + navigableSet);

navigableSet.pollLast();

System.out.println("Set after pollLast " +navigableSet);

}

}

Output:


Set : [1, 2]
Set After pollFirst [2]
Set [2, 3, 4]
Set after pollLast [2, 3]

Java Collections Tutorial Navigable Map Example

package JAVATUTORIAL;
import java.util.*;
import java.util.concurrent.*;

public class NavigableMapTutorial{
      public static void main(String[] args) {
        System.out.println("Navigable Map Example!\n");
        NavigableMap navMapObj = new
                           ConcurrentSkipListMap();
        navMapObj.put(1, "S");
        navMapObj.put(2, "February");
        navMapObj.put(3, "March");
        navMapObj.put(4, "April");
        navMapObj.put(5, "May");
        navMapObj.put(6, "June");
        navMapObj.put(7, "July");
        navMapObj.put(8, "August");
        navMapObj.put(9, "September");
        navMapObj.put(10, "October");
        navMapObj.put(11, "November");
        navMapObj.put(12, "December");
        //Displaying all data
        System.out.println("Data in Navigable Map is : " +
                                              navMapObj.descendingMap()+"\n");
        //Retrieving first data
        System.out.print("First data: " + navMapObj.firstEntry()+"\n");
        //Retrieving last data
        System.out.print("Last data: " + navMapObj.lastEntry()+"\n\n");
        //Retrieving the nreatest less than or equal to the given key
        System.out.print("Nearest less than or equal to the given key: "
                                + navMapObj.floorEntry(5)+"\n");
        //Retrieving the greatest key strictly less than the given key
        System.out.println("Retrieving the greatest key strictly less than the given key"+ navMapObj.lowerEntry(3));
        //Retrieving a key-value associated with the least key
                        //strictly greater than the given key
        System.out.println("Retriving data from navigable map greter than   the given key: " + navMapObj.higherEntry(5)+"\n");
        //Removing first
        System.out.println("Removing First: " + navMapObj.pollFirstEntry());
        //Removing last
        System.out.println("Removing Last: " + navMapObj.pollLastEntry()+"\n");
        //Displaying all data
        System.out.println("Now data: " + navMapObj.descendingMap());
      }
    }
     
Description of program:

The following program helps you in inserting, removing and retrieving the data from the NavigableMap. It uses the put() method to add the element. If you want to retrieve the data at first and last position from the NavigableMap, you use the firstEntry() and lastEntry() methods. The descendingMap() method represents all data to the NavigableMap in descending order.

You can retrieve the nearest less than or equal to the given number and the greatest key strictly less than the given number floorEntry() and lowerEntry() methods. And you retrieve a key-value associated with the least key strictly greater than the given key, you use the higherEntry() method. The pollFirstEntry() method removes the first data from the NavigableMap and pollLastEntry() method also removes the data at the last position from the NavigableMap.

JDK 6 Collections-related APIs & Developer Guides |Java 6.0 Collection Framework

Java 6.0 New Collection APIs an Overview
The following are the new collection APIs introduced in Java 6.0. I listes them as Interfaces and classes.
New Interfaces
  • Deque
  • BlockingDeque
  • NavigableSet
  • NavigableMap
New Classes
  • ArrayDeque
  • LinkedBlockingDeque
  • ConcurrentSkipListSet
  • ConcurrentSkipListMap
  • AbstractMap.SimpleEntry
  • AbstractMap.SimpleImmutableEntry
Updated Classes in Java 6.0
  • LinkedList
  • TreeSet
  • TreeMap
  • Collections

Advantages and Disadvantages of the Java Collection Framework

A collection is simply an object that groups multiple elements into a single unit. It is also called as a container sometimes. It is used to store, retrieve, manipulate, and communicate aggregate data. Typically, it represents data items that form a natural group and allows duplicate elements while others do not. It consists of both ordered and unordered elements. 

The primary advantages of a collections framework are that it:

Reduces programming effort by providing useful data structures and algorithms so you don't have to write them yourself.
Increases performance by providing high-performance implementations of useful data structures and algorithms. Because the various implementations of each interface are interchangeable, programs can be easily tuned by switching implementations.
Provides interoperability between unrelated APIs by establishing a common language to pass collections back and forth.
Reduces the effort required to learn APIs by eliminating the need to learn multiple ad hoc collection APIs.
Reduces the effort required to design and implement APIs by eliminating the need to produce ad hoc collections APIs.
Fosters software reuse by providing a standard interface for collections and algorithms to manipulate them.

Disadvantages of collections framework:

It must cast to correct type.
It can't be done compile-time type checking.

What is Collection Framework in Java?

A collection is an object that represents a group of objects (such as the familiar Vector class). A collections framework is a unified architecture for representing and manipulating collections, allowing them to be manipulated independently of the details of their representation.

collections is a group of objects known as its elements. Basically it is a package of data structures that includes ArrayLists, LinkedLists, HashSets, etc. A collection is simply an object that groups multiple elements into a single unit. It is also called as a container sometimes. It is used to store, retrieve, manipulate, and communicate aggregate data. Typically, it represents data items that form a natural group and allows duplicate elements while others do not. It consists of both ordered and unordered elements. There is no direct implementation of this interface however SDK provides implementations of more specific sub interfaces like Set and List. The manipulation and passing of collections is done by this interface.