Java Collection Interface

• Collection is an interface inwards java.
• Collection interface extends Iterable interface.
• In hierarchy, Collection interface is rootage of List, Queue together with Set interfaces.

• It represents unit of measurement of its elements. i.e. grouping of objects.
• Some collections produce non permit duplicate elements exactly about allows duplicate elements.
• Collection interface is base of operations on which collection framework is built.
• Collection interface contains basic functioning methods every bit bellow.

• boolean add(E element) - To brand certain that this collection contains the specified element. It volition supply truthful if object is added to collection. Return imitation if object is already at that spot together with collection does non permit duplicates.
• boolean contains(Object element) - It volition supply truthful if collection already accept specified element.
• boolean isEmpty() - Return truthful if collection is empty.
• Iterator<E> iterator() - It volition supply an iterator for the invoking collection.
• boolean remove(Object element) - It volition take away unmarried instance of given chemical part from collection. Return truthful if it is introduce else it volition supply false.
• int size() - It volition supply seat out of elements introduce inwards invoking collection.

•  Collection interface besides contains methods that operate on entire collections every bit bellow.

• boolean addAll(Collection<? extends E> c) - It volition add together all elements of c to the invoking collection. Return truthful if functioning was success else it volition supply false.
• boolean containsAll(Collection<?> c) - It volition supply truthful if this collection contains all the elements of specified collection.
• void clear() - It volition take away all the elements from invoking collection.
• boolean removeAll(Collection<?> c) - It volition take away all those elements from invoking collection which are available inwards c. It volition supply truthful if given elements removed else it volition supply false.
• boolean retainAll(Collection<?> c) - Retains all the elements inwards invoking collection which are available inwards c.

• Also at that spot are methods to perform array operations every bit bellow.

• Object[] toArray() - Return array of elements from invoking collection.
• <T> T[] toArray(T[] a) - Return array of all those elements from collection.

Basic Example of Collection

package JAVAExamples;  import java.util.ArrayList; import java.util.Collection; import java.util.LinkedList;  world shape CollectionExample {   world static void main(String[] args) {    // Collection ArrayList.   Collection<String> c1 = novel ArrayList<String>();   // Add items inwards ArrayList.   c1.add("ArrayList Item 1");   c1.add("ArrayList Item 2");   c1.add("ArrayList Item 3");   c1.add("ArrayList Item 4");   // Get collection Items list.   System.out.println("Collection Items are : " + c1);   // Get size of collection.   System.out.println("Size of collection is : " + c1.size());   // Remove exceptional from collection.   c1.remove("ArrayList Item 3");   System.out.println("Collection Items are : " + c1);    System.out.println();   System.out.println();           // Collection LinkedList.   Collection<String> c2 = novel LinkedList<String>();   // Add items inwards LinkedList.   c2.add("LinkedList Item 1");   c2.add("LinkedList Item 2");   c2.add("LinkedList Item 3");   c2.add("LinkedList Item 4");   // Get collection Items list.   System.out.println("Collection Items are : " + c2);   // Get size of collection.   System.out.println("Size of collection is : " + c2.size());   // Remove exceptional from collection.   c2.clear();   System.out.println("Collection Items are : " + c2);  } }

Output :

Collection Items are : [ArrayList Item 1, ArrayList Item 2, ArrayList Item 3, ArrayList Item 4] Size of collection is : four Collection Items are : [ArrayList Item 1, ArrayList Item 2, ArrayList Item 4]   Collection Items are : [LinkedList Item 1, LinkedList Item 2, LinkedList Item 3, LinkedList Item 4] Size of collection is : four Collection Items are : []

So this is basic regard of rootage collection interface. We volition larn dissimilar nestling interfaces of collection interface i past times i to buy the farm regard nearly how collection interface works.

<< PREVIOUS || NEXT >>

Java Listing Interface

• List interface inwards coffee is ordered collection then it tin shop elements inwards sequence.
• List interface is sub interface too it extends to Collection interface.
• List interface tin concur duplicate elements then you lot tin insert duplicate elements too.
• You tin access elements from listing past times integer index.
• Collection framework has many interfaces inwards coffee too listing interface is ane of them.
• List interface provides ListIterator to traverse through elements listing inwards backward too frontward directions.

Few by too large used methods inwards listing interface are equally bellow.

• void add(int index,Object element) : It volition insert chemical cistron at specified index seat inwards list.
• boolean addAll(int index,Collection c) : It volition add together all elements of given collection inwards to the listing at specified index position.
• object get(int Index ) : It volition render object at specified index seat from list.
• object set(int index,Object element) : It volition assign object at specified index seat inwards list.
• object remove(int index) : It volition take away object from specified position.
• ListIterator listIterator() : It volition returns the listing iterator at start of invoking list.
• ListIterator listIterator(int x) : It volition returns the listing iterator at specified index seat inwards list.
• int indexOf(Object obj) : It volition render index of rootage illustration of object from invoking list.
• int lastIndexOf(Object obj) : It volition render index of concluding illustration of object from invoking list.

List interface is implemented past times many classes similar Arraylist, Linkedlist too Vector.  Here, I accept represented illustration of listing interface using few methods from dissimilar degree implementation.

package JAVAExamples;  import java.util.ArrayList; import java.util.LinkedList; import java.util.List; import java.util.ListIterator;  populace degree InterfaceList {   populace static void main(String[] args) {   // Add elements inwards ArrayList.   List al = novel ArrayList();   al.add("New York");   al.add("Delhi");   al.add("Tokyo");      // Print arraylist elements.   System.out.println("ArrayList Elements");   System.out.print(al);   System.out.println();    // Add elements inwards linkedlist.   List ll = novel LinkedList();   ll.add("New York");   ll.add("Delhi");   ll.add("Tokyo");      // Print linkedlist elements.   System.out.println();   System.out.println("LinkedList Elements");   System.out.print(ll);   System.out.println();    // Get too impress arraylist's third element.   System.out.println();   System.out.println("Element at third seat inwards arralist is : " + al.get(2));    // Using ListIterator to traverse through frontward too backward directions inwards arralist.   ListIterator<String> itrtr = al.listIterator();    // Traverse inwards frontward direction.   System.out.println();   System.out.println("Traversing through arralist elements inwards frontward direction...");   piece (itrtr.hasNext()) {    System.out.println(itrtr.next());   }    // Traverse inwards backward direction.   System.out.println();   System.out.println("Traversing through arralist elements inwards backward direction...");   piece (itrtr.hasPrevious()) {    System.out.println(itrtr.previous());   }  } }

Output

ArrayList Elements [New York, Delhi, Tokyo]  LinkedList Elements [New York, Delhi, Tokyo]  Element at third seat inwards arralist is : Tokyo  Traversing through arralist elements inwards frontward direction... New York Delhi Tokyo  Traversing through arralist elements inwards backward direction... Tokyo Delhi New York

In higher upwardly illustration you lot tin encounter how arralist, linkedlist, croak method too listiterator works.

<< PREVIOUS || NEXT >>

Java Collections Framework

What is Java Collections Framework?

Java Collections Framework is grouping of dissimilar interfaces, classes as well as algorithms. In uncomplicated word, Collection agency unmarried unit of measurement of objects as well as framework agency skilful architecture. It is best architecture to shop grouping of reusable objects as well as manipulate them. Collection framework has many dissimilar interfaces, their sub interfaces as well as classes, their classes as well as sub classes. All the interfaces as well as classes has dissimilar purpose. You tin perform add, edit, delete, search, sort, etc operations on grouping of objects equally per class's methods as well as implementation.

Main Advantages Of Collection Framework

• Main payoff of collection framework is it volition reduces your programming efforts equally at that spot are stimulate made interfaces, classes as well as their methods which you lot tin utilisation straight inwards your programme to perform performance on object collection. 
• Collection is good construction framework as well as then you lot code lineament as well as speed volition hold out increased.
• Anyone tin utilisation collection real easily equally it's interfaces, classes as well as methods real tardily to sympathize as well as use.

Interfaces as well as Classes of Collection Framework

Collection, Set, List, Queue, Deque, SortedSet, Map as well as SortedMap are essence interfaces of collection framework. Detailed description of collection framework's interfaces as well as it's classes is given on below given pages.

• Java Collection Interface
• Java List Interface
• Java ArrayList Class
• LinkedList In Java
• Vector Class In Java
• Stack Class inwards Java
• Java Queue Interface
• Java PriorityQueue Class
• Java Deque Interface
• Java ArrayDeque Class
• Java Set Interface And Methods
• Java LinkedHashSet Class
• HashSet inwards Java Collection Example
• Java SortedSet Interface
• Java TreeSet Class
• Java Hashtable Class
• Java Map Interface
• Java HashMap Class
• LinkedHashMap Class In Java

<< PREVIOUS || NEXT >>

Vector Cast Inwards Java

• Vector cast inwards coffee implements List interface of collection framework.
• Vector cast is synchronized.
• If you lot don't know size of array therefore you lot tin piece of employment vector cast every bit size of vector tin grow together with shrink every bit per adding together with removing items.
• As vector cast is synchronized, It volition rank pitiable performance on add, delete, update together with search operations.
• Elements of vector tin live accessed using it's integer index.

Important method of vector class

• void addElement(Object element) : It volition add together specified chemical component at destination of vector.
• int capacity() : It volition supply the electrical flow capacity of vector.
• int size() : This method volition supply electrical flow size of vector.
• void setSize(int size) : It volition gear upwards size of vector using given size value.
• boolean contains(Object element) : It volition supply truthful if specified chemical component acquaint inwards vector. Else it volition supply false.
• boolean containsAll(Collection c) : It volition supply truthful if vector contains all values of given collection c.
• Object elementAt(int index) : It volition supply chemical component which is located at specified index of vector.
• Object firstElement() : It volition supply get-go chemical component of vector.
• Object lastElement() : It volition supply concluding chemical component of vector.
• Object get(int index) : It volition supply chemical component located at the specified index of vector.
• boolean isEmpty() : It volition supply truthful if vector is empty.
• boolean removeElement(Object element) : It volition take given chemical component from vector.
• boolean removeAll(Collection c) : It volition take all elements of collection c from vector.
• void setElementAt(Object element, int index) : It volition gear upwards specified chemical component at given index of vector.

Bellow given sample plan volition demo you lot how to piece of employment vector cast together with it's unlike methods.

Vector cast example

package JAVAExamples;  import java.util.Enumeration; import java.util.Vector;  populace cast VectorExample {  populace static void main(String args[]) {   //Initial vector capacity is 2. Increment it past times 2 when required.   Vector 5 = novel Vector(2,2);   System.out.println("Initial capacity of vector : "+v.capacity());   v.addElement("one");   v.addElement("two");   v.addElement("three");     System.out.println("Capacity of vector subsequently adding 3 elements inwards vector : "+v.capacity());    //Get size of vector.   System.out.println("Size of vector : "+v.size());    //Get get-go chemical component of vector.   System.out.println("First chemical component of vector : "+v.firstElement());      //Get concluding chemical component of vector.   System.out.println("Last chemical component of vector : "+v.lastElement());      //Add novel chemical component inwards vector.   v.add(2, "New Element");      //Print all elements of vector using Enumeration.   Enumeration vEnum = v.elements();   System.out.print("Current vector elements : ");   while(vEnum.hasMoreElements()){    System.out.print(vEnum.nextElement() + ", ");   }      System.out.println();      //Check if vector is empty.   System.out.println("Vector is empty? : "+v.isEmpty());    } }

Output :

Initial capacity of vector : 2 Capacity of vector subsequently adding 3 elements inwards vector : four Size of vector : 3 First chemical component of vector : 1 Last chemical component of vector : 3 Current vector elements : one, two, New Element, three,  Vector is empty? : false

Above instance shows you lot usage of by together with large used methods of vector class. http://www.feedbooks.com/user/4455042/profile

<< PREVIOUS || NEXT >>

Stack Degree Inwards Coffee Example

• Stack bird inward coffee is i of the collection interface bird which is subclass of Vector class.
• Stake bird supports park force together with popular operations.
• In contrast to queue, Stack bird has last-in first-out(LIFO) information structure. So detail which is inserted at hap volition live available first.
• Stack bird extends Vector bird of List interface therefore it includes all methods of vector bird together with likewise it has it's ain several methods to perform force together with popular operations similar looking hap detail from stack, removing hap detail from stack, force novel detail at hap of stack, searching detail from stack together with cheque whether stack is empty.

Important Methods of Stack Class inward Java

• boolean empty() : This method of stack bird volition manage y'all to cheque if stack is empty.
• Object peek( ) : It volition expect together with provide hap chemical subdivision of stack. It volition non take away chemical subdivision from stack.
• Object pop( ) : It volition take away detail from hap of the stack together with provide the value.
• Object push(E item) : It volition force an detail on hap of the stack
• int search(Object o) : It volition lift one's heed if object is be inward stack. If be together with then it volition provide item's index. Top detail of stack has index = 1.

Below given practical instance of coffee stack bird volition present y'all how to a higher house methods work.

package JAVAExamples;  import java.util.Stack;  world bird JavaStackExample {  world static void main(String args[]) {   //Create stc stack.   Stack stc = novel Stack();   //Initially stack volition live empty.   System.out.println("Stack is empty? : "+stc.empty());   //Push items inward stack.   stc.push("Item1");   stc.push("Item2");   stc.push("Item3");   //Now stack if filled.   System.out.println("Now stack empty? : "+stc.empty());   //Print stack items.   System.out.println("stack Ietms : " + stc);   //Get hap detail from stack.   System.out.println("Top detail inward stack is : "+stc.peek());   //Print stack items afterwards peek.   System.out.println("stack Ietms afterwards peek : " + stc);   //Get together with take away hap detail from stack.   System.out.println("Get hap detail from stack together with removed it from stack : "+stc.pop());   //Print stack items afterwards pop.   System.out.println("stack Ietms afterwards popular : " + stc);   //Push novel detail inward stack.   stc.push("Item4");   //Print stack afterwards inserting novel item.   System.out.println("Now stack Ietms are : " + stc);   //Search detail from stack which is available.   System.out.println("Search Item1 inward stack is at index : "+stc.search("Item1"));   //Search detail from stack which is non available inward stack.   System.out.println("Search Item7 inward stack which is non available is : "+stc.search("Item7"));  } }

Output :

Stack is empty? : truthful Now stack empty? : faux stack Ietms : [Item1, Item2, Item3] Top detail inward stack is : Item3 stack Ietms afterwards peek : [Item1, Item2, Item3] Get hap detail from stack together with removed it from stack : Item3 stack Ietms afterwards popular : [Item1, Item2] Now stack Ietms are : [Item1, Item2, Item4] Search Item1 inward stack is at index : iii Search Item7 inward stack which is non available is : -1

Now i intend y'all volition empathize how together with when to role stack bird inward java.

<< PREVIOUS || NEXT >>

Java Queue Interface

• If you lot hold back at collection hierarchy, Queue extends collection interface.
• Main operate of collection is to concur the elements prior to processing.
• Queue interface provides to a greater extent than or less additional operations similar insertion, inspection too extraction too collection interface operations.
• All these 3 operations be inwards 2 dissimilar forms. One render exceptional value(null or faux depending on the operation) if functioning fails else throws an exception if functioning fails.
• Queue follows FIFO(first-in-first-out) too then it volition insert chemical component subdivision at the terminate of the queue when you lot insert novel chemical component subdivision too chemical component subdivision volition endure removed from the kickoff of the queue when you lot withdraw element.
• As Queue interface is sub type of collection interface, all methods of collection interface are also available in Queue interface.

 Basic methods of Queue interface
Few of the basic Queue interface methods are every bit below.

• boolean add(E e) : It volition insert an chemical component subdivision inwards queue if infinite is available inwards queue. Else it volition render IllegalStateException.
• E element() : It volition render head(first element) of queue if queue inwards non empty. It volition render NoSuchElementException exception if Queue is empty.
• boolean offer(E e) : It volition insert chemical component subdivision inwards queue if infinite is available inwards queue.
• E peek() : It volition render head(first element) of queue if queue inwards non empty. Else it volition render null.
• E poll() : It volition think too withdraw head(first element) of the element. Return cipher if queue is empty.
• E remove() : It volition think too withdraw head(first element) of the element. It volition render NoSuchElementException exception if Queue is empty.

I accept prepared instance on basic Queue interface methods to present demo how they works.

Queue Interface Example

package JAVAExamples;  import java.util.LinkedList; import java.util.Queue;  world course of teaching QueueExample {   world static void main(String[] args) {   //Creating queue.   Queue q = novel LinkedList();      //Inserting elements inwards queue.   q.add("three");   q.add("two");   q.add("one");     q.add("four");   q.add("six");   q.add("seven");   q.add("five");      //Print queue elements.   System.out.println("Queue elements are : "+q);      //Removing firstly inserted chemical component subdivision from queue using withdraw method.   q.remove();   System.out.println("Queue elements afterward chemical component subdivision removal using withdraw method : "+q);      //retrieve caput of queue (first element) using chemical component subdivision method.   System.out.println("Now firstly chemical component subdivision inwards queue is : "+q.element());      //Insert chemical component subdivision inwards queue using offering method.    q.offer("eight");   System.out.println("Queue elements afterward inserting chemical component subdivision using offering method : "+q);      //Removing specific chemical component subdivision from queue.   q.remove("six");   System.out.println("Queue elements afterward removing half dozen chemical component subdivision : "+q);    //Removing caput of queue (first element) using poll method.   q.poll();   System.out.println("Queue elements afterward removing chemical component subdivision using poll method : "+q);      //retrieve caput of queue (first element) using peek method.   System.out.println("Now firstly chemical component subdivision inwards queue is : "+q.peek());    } }

Output :

Queue elements are : [three, two, one, four, six, seven, five] Queue elements afterward chemical component subdivision removal using withdraw method : [two, one, four, six, seven, five] Now firstly chemical component subdivision inwards queue is : 2 Queue elements afterward inserting chemical component subdivision using offering method : [two, one, four, six, seven, five, eight] Queue elements afterward removing half dozen chemical component subdivision : [two, one, four, seven, five, eight] Queue elements afterward removing chemical component subdivision using poll method : [one, four, seven, five, eight] Now firstly chemical component subdivision inwards queue is : one

<< PREVIOUS || NEXT >>

Java Arraydeque Class

• ArrayDeque is ane of the collection framework fellow member which implements Deque, Cloneable together with Serializable interfaces.
• ArrayDeque provides Resizable-array implementation thus it has no capacity restrictions together with it volition grow every bit per requirement.
• In the absence of external synchronization, they are non thread safe. So they produce non permit multiple threads to access it concurrently.
• Also ArrayDequenot permit to shop zip elements.
• ArrayDeque Class is faster than LinkedList when used every bit a queue together with faster than Stack when used every bit a stack.
• If ArrayDeque is modified afterward the iterator creation together with if it is non modified past times iterators ain method together with then it volition throw ConcurrentModificationException. So inwards concurrent modification, Iterator volition fail.

Important methods of ArrayDeque Class

• boolean add(E e) : It volition insert given chemical share inwards ArrayDeque.
• void addFirst(E e) : It volition add together given chemical share at the kickoff of ArrayDeque.
• void addLast(E e) : It volition add together given chemical share at the destination of ArrayDeque.
• void clear() : It volition take away all elements from ArrayDeque to clear it.
• ArrayDeque<E> clone() : It volition render re-create of ArrayDeque.
• boolean contains(Object o) : It volition render truthful if specified chemical share available inwards ArrayDeque.
• Iterator<E> descendingIterator() : It volition render iterator inwards contrary sequential social club over the elements of ArrayDeque.
• E element() : It volition croak head(first) chemical share from this ArrayDeque.
• E getFirst() : It volition croak head(first) chemical share from this ArrayDeque.
• E getLast() : It volition croak concluding chemical share from this ArrayDeque.
• boolean isEmpty() : It volition render truthful if ArrayDeque is empty.
• boolean offer(E e) : It volition insert specified chemical share at the destination of this ArrayDeque.
• boolean offerFirst(E e) : It volition insert specified chemical share at the kickoff of this ArrayDeque.
• boolean offerLast(E e) : It volition insert specified chemical share at the destination of this ArrayDeque.
• E peek() : It volition recall together with render caput chemical share from ArrayDeque. Return zip if ArrayDeque is empty.
• E peekFirst() : It volition recall together with render head(first) chemical share from ArrayDeque. Return zip if ArrayDeque is empty.
• E peekLast() : It volition recall together with render concluding chemical share from ArrayDeque. Return zip if ArrayDeque is empty.
• E poll() : It volition take away caput chemical share from ArrayDeque. Return zip if ArrayDeque is empty.
• E pollFirst() : It volition take away head(first) chemical share from ArrayDeque. Return zip if ArrayDeque is empty.
• E pollLast() : It volition take away concluding chemical share from ArrayDeque. Return zip if ArrayDeque is empty.
• E pop() : It volition popular an chemical share from stack represented past times this ArrayDeque.
• void push(E e) : It volition pushes an chemical share on stack represented past times this ArrayDeque.
• E remove() : It volition take away caput chemical share of the ArrayDeque.
• boolean remove(Object o) : It volition take away unmarried illustration of specified object from ArrayDeque.
• E removeFirst() : It volition take away firstly chemical share from ArrayDeque.
• boolean removeFirstOccurrence(Object o) : It volition take away firstly occurrence of the chemical share from ArrayDeque.
• E removeLast() : It volition take away concluding chemical share from ArrayDeque.
• boolean removeLastOccurrence(Object o) : It volition take away concluding occurrence of the chemical share from ArrayDeque.
• int size() :It volition render size of ArrayDeque.
• Object[] toArray() : It volition render elements array from ArrayDeque.
• <T> T[] toArray(T[] a) : It volition render elements array from ArrayDeque. The runtime type of the returned array is that of the specified array.

Below given illustration volition exhibit you lot demo of higher upwardly ArrayDeque  method's usage.

ArrayDeque Example

package JAVAExamples;  import java.util.ArrayDeque; import java.util.Deque;  populace shape ArrayDequeExample {   populace static void main(String[] args) {   // Create ArrayDeque.   ArrayDeque<String> d = novel ArrayDeque<String>();   // Add elements inwards Deque.   d.add("one");   d.add("two");   d.add("three");   d.add("four");   d.add("five");   d.add("four");   d.add("six");   // Print Deque elements.   System.out.println("Deque elements are : " + d);    // Add chemical share at firstly of Deque.   d.addFirst("First Added");   System.out.println("Deque elements afterward addFirst are : " + d);    // Add chemical share at concluding of Deque.   d.addLast("Last Added");   System.out.println("Deque elements afterward addLast are : " + d);    // Get firstly chemical share from Deque.   System.out.println("First chemical share inwards deque is : " + d.getFirst());    // Get concluding chemical share from Deque.   System.out.println("Last chemical share inwards deque is : " + d.getLast());    // Get firstly chemical share from Deque using peek.   System.out.println("First chemical share inwards deque using peek is : " + d.peek());    // Get concluding chemical share from Deque using peekLast.   System.out.println("Last chemical share inwards deque using peekLast is : " + d.peekLast());    // Remove firstly chemical share from deque.   d.removeFirst();   System.out.println("Deque elements afterward removeFirst are  : " + d);    // Using pop.   d.pop();   System.out.println("Deque elements afterward popular are  : " + d);    // Using push.   d.push("First");   System.out.println("Deque elements afterward force are  : " + d);    // Remove LastOccurrence of chemical share from deque using removeLastOccurrence.   d.removeLastOccurrence("four");   System.out.println("Deque elements afterward removeLastOccurrence are  : "+ d);    // Get size of deque.   System.out.println("Size of Deque is  : " + d.size());  } }

Output :

Deque elements are : [one, two, three, four, five, four, six] Deque elements afterward addFirst are : [First Added, one, two, three, four, five, four, six] Deque elements afterward addLast are : [First Added, one, two, three, four, five, four, six, Last Added] First chemical share inwards deque is : First Added Last chemical share inwards deque is : Last Added First chemical share inwards deque using peek is : First Added Last chemical share inwards deque using peekLast is : Last Added Deque elements afterward removeFirst are  : [one, two, three, four, five, four, six, Last Added] Deque elements afterward popular are  : [two, three, four, five, four, six, Last Added] Deque elements afterward force are  : [First, two, three, four, five, four, six, Last Added] Deque elements afterward removeLastOccurrence are  : [First, two, three, four, five, six, Last Added] Size of Deque is  : 7

<< PREVIOUS || NEXT >>

Java Sortedset Interface

• SortedSet interface extends Set interface inwards collection framework of java.
• As parent suggest, It provides full ordering on elements of Set.
• Set elements volition live ordered using their natural ordering or using a comparator interface.
• All the elements entries of SortedSet must implement Comparable interface.
• All the elements of SortedSet must live comparable. So e1.compareTo(e2) must non throw ClassCastException.
• In collection framework, TreeSet cast is an implementation for the SortedSet interface.

Few of import as well as useful methods of SortedSet Interface are every bit bellow.

• Comparator comparator( ) : It volition render the comparator which is used to guild the elements inwards invoking set. If elements of laid upwards are ordered using natural ordering as well as then it volition render null.
• Object first( ) : It volition render the starting fourth dimension chemical component subdivision from the set.
• SortedSet headSet(E toElement) : It volition render those elements from SortedSet which are  strictly less than toElement. toElement volition live non included.
• Object last() : It volition render electrical current concluding chemical component subdivision from the set.
• SortedSet subSet(E fromElement, eastward toElement) : It volition render laid upwards of elements from SortedSet starting from fromElement to toElement. fromElement volition live included simply toElement volition live excluded.
• SortedSet tailSet(E fromElement) : It volition render laid upwards of elements starting from fromElement.

Usage of inwards a higher house SortedSet methods is described inwards below given example.

SortedSet Example :

package JAVAExamples;  import java.util.Iterator; import java.util.SortedSet; import java.util.TreeSet;  world cast SortedsetInterface {   world static void main(String[] args) {   // Create the sorted set.   SortedSet<String> s = novel TreeSet<String>();    // Add items to the sorted.   s.add("New York");   s.add("Delhi");   s.add("Tokyo");   s.add("London");   s.add("Mumbai");   s.add("Chennai");    // Iterate over the elements of laid upwards as well as print.   Iterator<String> it = s.iterator();   System.out.println("SortedSet Items are : ");   spell (it.hasNext()) {    Object chemical component subdivision = it.next();    System.out.println(element.toString());   }      //Get starting fourth dimension detail from set.   System.out.println("First detail inwards laid upwards : "+s.first());   //Get concluding detail from set.   System.out.println("Last detail inwards laid upwards : "+s.last());    // Using subSet method to become items from given FROM as well as TO elements of set.   // TO chemical component subdivision volition live excluded.   System.out.println("subSet items betwixt Delhi as well as New York : " + s.subSet("Delhi", "New York"));   // Using headSet method to become heading items from given item.   System.out.println("headSet from London : " + s.headSet("London"));   // Using tailSet method to become tailing items from given item.   System.out.println("tailSet from London : " + s.tailSet("London"));   // Check which comparator is used to variety elements.   // If render nada as well as then it has used natural ordering.   System.out.println(s.comparator());  } }

Output :

SortedSet Items are :  Chennai Delhi London Bombay New York Tokyo First detail inwards laid upwards : Chennai Last detail inwards laid upwards : Tokyo subSet items betwixt Delhi as well as New York : [Delhi, London, Mumbai] headSet from London : [Chennai, Delhi] tailSet from London : [London, Mumbai, New York, Tokyo] null

<< PREVIOUS || NEXT >>

Java Treeset Class

• TreeSet is course of teaching nether Set interface of collection framework.
• It implements NavigableSet interface which extends SortedSet interface.
• Elements are ordered by a Comparator which is provided at laid creation fourth dimension or yesteryear natural ordering.
• It maintains the ascending sorting order.
• TreeSet is non synchronized thence if multiple threads accessing it concurrently in addition to whatever i modifies laid entry in addition to thence it must live synchronized externally.
• Element's access in addition to retrieval fourth dimension is really fast from TreeSet thence it volition much useful when you lot wants to shop large information inwards ascending social club in addition to hollo back whatever chemical cistron quickly.

Important methods of TreeSet course of teaching are equally below.

• boolean add(E e) : It volition insert specified chemical cistron inwards TreeSet if it is non already exist.
• boolean addAll(Collection<? extends E> c) : It volition insert all entries of specified collection inwards to TressSet.
• E ceiling(E e) : Get to the lowest degree chemical cistron from the laid which is greater than or equals to the given chemical cistron E. If non institute whatever in addition to thence it volition render null.
• void clear() : It volition take away all elements from set.
• Object clone() : It volition render shallow re-create of this Set instance
• Comparator<? super E> comparator() : It volition render the comparator if whatever used to social club the elements inwards this set. Return goose egg if laid is sorted using natural ordering.
• boolean contains(Object o) : It volition render truthful if specified chemical cistron is available inwards list.
• Iterator<E> descendingIterator() : It volition render the descending social club iterator over the set.
• NavigableSet<E> descendingSet() : It volition render contrary social club thought of laid elements.
• E first() : It volition render electrical flow receive down chemical cistron from set.
• E floor(E e) : It volition render you lot greatest chemical cistron from the laid which is less than or equals to the specified element. If non institute whatever in addition to thence it volition render null.
• SortedSet<E> headSet(E toElement) : It volition render subdivision of laid elements which are strictly less than given toElement.
• NavigableSet<E> headSet(E toElement, boolean inclusive) : It volition render subdivision of laid elements which are less than given toElement. toElement volition live included if inclusive is true.
• E higher(E e) : It volition render to the lowest degree chemical cistron from laid which is strictly greater than the specified element. Return goose egg fi non institute any.
• boolean isEmpty() : It volition render truthful if TreeSet is empty.
• Iterator<E> iterator() : It volition render the iterator over elements of set.
• E last() : It volition render terminal chemical cistron from set.
• E lower(E e) : It volition render greatest chemical cistron from laid which is strictly less than the given element. If non institute whatever in addition to thence it volition render null.
• E pollFirst() : It volition access in addition to take away receive down (lowest) chemical cistron from the set. If laid is empty in addition to thence it volition render null.
• E pollLast() : It volition access in addition to take away terminal (highest) chemical cistron from the set. If laid is empty in addition to thence it volition render null.
• boolean remove(Object o) : It volition take away given chemical cistron from the set(if it is preset).
• int size() :It volition render size of set.
• NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) : It volition render subdivision of laid starting from fromElement to toElement. fromElement volition live included inwards laid subdivision if fromInclusive is true. toElement volition live included inwards laid subdivision if toInclusive is true.
• SortedSet<E> subSet(E fromElement, E toElement) : It volition render subdivision of laid starting from fromElement(Included) to toElement(Excluded).
• SortedSet<E> tailSet(E fromElement) : It volition render tail laid starting from fromElement. fromElement volition live included inwards set.
• NavigableSet<E> tailSet(E fromElement, boolean inclusive) : It volition render tail laid starting from fromElement. fromElement volition live included inwards laid if inclusive is true.

Below given representative volition demo you lot usage of few TreeSet class's method's demo.

TreeSet Example :

package JAVAExamples;  import java.util.Iterator; import java.util.TreeSet;  populace course of teaching TreeSetExample {   populace static void main(String[] args) {   // Create TreeSet.   TreeSet<Integer> ts = novel TreeSet<Integer>();   // Add elements inwards TreeSet.   ts.add(5);   ts.add(79);   ts.add(9);   ts.add(52);   ts.add(3);   ts.add(69);   ts.add(52);   ts.add(76);   ts.add(15);   ts.add(42);   ts.add(93);   ts.add(334);    // Print TreeSet.   System.out.println("TreeSet elements are : " + ts);   // Get ceiling value from treeset.   System.out.println("ceiling of 45 inwards treeset is : " + ts.ceiling(45));   // Get clone of treeset.   System.out.println("clone of treeset is : " + ts.clone());   // Check if treeset contains given element.   System.out.println("treeset contains 76? : " + ts.contains(76));    // Print treeset inwards descending order.   Iterator iterator;   iterator = ts.descendingIterator();   System.out.println("Tree laid information inwards descending order: ");   spell (iterator.hasNext()) {    System.out.println(iterator.next() + " ");   }    // Get receive down chemical cistron from treeset.   System.out.println("First chemical cistron inwards treeset is : " + ts.first());   // Get terminal chemical cistron from treeset.   System.out.println("Last chemical cistron inwards treeset is : " + ts.last());   // Get flooring chemical cistron from treeset.   System.out.println("floor chemical cistron of 51 is : " + ts.floor(51));   // Get size of treeset.   System.out.println("Size of treeset is : " + ts.size());   // Remove receive down chemical cistron from treeset.   ts.pollFirst();   System.out.println("TreeSet elements later pollFirst : " + ts);   // Remove terminal chemical cistron from treeset.   ts.pollLast();   System.out.println("TreeSet elements later pollLast : " + ts);   // Get tailset exclusive fromElement.   System.out.println("tail laid from 69 is : " + ts.tailSet(69, false));   // Get subset exclusive fromElement in addition to toElement.   System.out.println("subset laid from ix in addition to 76 exclusive is : "+ ts.subSet(9, false, 76, false));   // Get subset inclusive fromElement in addition to toElement.   System.out.println("subset laid from ix in addition to 76 inclusive is : "+ ts.subSet(9, true, 76, true));  } }

Output :

TreeSet elements are : [3, 5, 9, 15, 42, 52, 69, 76, 79, 93, 334] ceiling of 45 inwards treeset is : 52 clone of treeset is : [3, 5, 9, 15, 42, 52, 69, 76, 79, 93, 334] treeset contains 76? : truthful Tree laid information inwards descending order:  334  93  79  76  69  52  42  xv  ix  v  iii  First chemical cistron inwards treeset is : iii Last chemical cistron inwards treeset is : 334 flooring chemical cistron of 51 is : 42 Size of treeset is : eleven TreeSet elements later pollFirst : [5, 9, 15, 42, 52, 69, 76, 79, 93, 334] TreeSet elements later pollLast : [5, 9, 15, 42, 52, 69, 76, 79, 93] tail laid from 69 is : [76, 79, 93] subset laid from ix in addition to 76 exclusive is : [15, 42, 52, 69] subset laid from ix in addition to 76 inclusive is : [9, 15, 42, 52, 69, 76]

<< PREVIOUS || NEXT >>