Getting ready for recording

Author: Ranga Rao Karanam

otherstuff.md

@@ -1,7 +1,9 @@
 package com.in28minutes.java.collections;
 
+import java.util.Comparator;
 import java.util.Iterator;
 import java.util.ListIterator;
+import java.util.concurrent.TimeUnit;
 
 //Java COLLECTION INTERVIEW QUESTIONS
 //�����������������������������������
@@ -60,39 +62,14 @@ interface Collection<E> extends Iterable<E> {
 	int hashCode();
 }
 
-// Unique things only - Does not allow duplication.
-// If obj1.equals(obj2) then only one of them can be in the Set.
-interface Set<E> extends Collection<E> {
-
-}
-
-// A, X , B
-// X, A ,B
-class HashSet /* implements Set */{
-	// unordered, unsorted - iterates in random order
-	// uses hashCode()
-}
-
-// A, X, B
-// A, X, B
-class LinkedHashSet /* implements Set */{
-	// ordered - iterates in order of insertion
-	// unsorted
-	// uses hashCode()
-}
-
-// A,C,B
-// A,B,C
-class TreeSet /* implements Set,NavigableSet */{
-	// 3,5,7
-	// sorted - natural order
-	// implements NavigableSet
-}
+//�����������������������������������
+//LIST,  RELATED INTERFACES AND CLASSES
+//�����������������������������������
 
-// LIST OF THINGS
-// Cares about which position each object is in
-// Elements can be added in by specifying position - where should it be added in
-// If element is added without specifying position - it is added at the end
+//LIST OF THINGS
+//Cares about which position each object is in
+//Elements can be added in by specifying position - where should it be added in
+//If element is added without specifying position - it is added at the end
 interface List<E> extends Collection<E> {
 
 	// [1,2,3,4]
@@ -144,28 +121,189 @@ class LinkedList /* implements List<E>, Queue */{
 	// and remove()
 }
 
+//�����������������������������������
+//SET RELATED INTERFACES AND CLASSES
+//�����������������������������������
+
+// Unique things only - Does not allow duplication.
+// If obj1.equals(obj2) then only one of them can be in the Set.
+interface Set<E> extends Collection<E> {
+
+}
+
+//Main difference between Set and SortedSet is - an implementation of SortedSet interface 
+//maintains its elements in a sorted order.  Set interface does not guarantee any Order.
+interface SortedSet<E> extends Set<E> {
+
+	SortedSet<E> subSet(E fromElement, E toElement);
+
+	SortedSet<E> headSet(E toElement);
+
+	SortedSet<E> tailSet(E fromElement);
+
+	E first();
+
+	E last();
+
+}
+
+//A SortedSet extended with navigation methods reporting closest matches for given search targets.
+interface NavigableSet<E> extends SortedSet<E> {
+	E lower(E e);
+
+	E floor(E e);
+
+	E ceiling(E e);
+
+	E higher(E e);
+
+	E pollFirst();
+
+	E pollLast();
+}
+
+// Order of Insertion : A, X , B
+// Possible Order of Storing : X, A ,B
+class HashSet /* implements Set */{
+	// unordered, unsorted - iterates in random order
+	// uses hashCode()
+}
+
+// Order of Insertion :A, X, B
+// Order of Storing : A, X, B
+class LinkedHashSet /* implements Set */{
+	// ordered - iterates in order of insertion
+	// unsorted
+	// uses hashCode()
+}
+
+// Order of Insertion :A,C,B
+// Order of Storing : A,B,C
+class TreeSet /* implements Set,NavigableSet */{
+	// 3,5,7
+	// sorted - natural order
+	// implements NavigableSet
+}
+
+//�����������������������������������
+//QUEUE  RELATED INTERFACES AND CLASSES
+//�����������������������������������
 // Arranged in order of processing - A to-do list for example
 // Queue interface extends Collection. So, it supports all Collection Methods.
 interface Queue<E> extends Collection<E> {
+
+	//Inserts the specified element into this queue
+	//Throws exception in case of failure
 	boolean add(E paramE);
 
+	//Inserts the specified element into this queue
+	//Returns false in case of failure
 	boolean offer(E paramE);
 
+	//Retrieves and removes the head of this queue.
+	//Throws Exception if Queue is empty
 	E remove();
 
+	//Retrieves and removes the head of this queue.
+	//returns null if Queue is empty
 	E poll();
 
 	E element();
 
 	E peek();
 }
 
+//A linear collection that supports element insertion and removal at both ends
+interface Deque<E> extends Queue<E> {
+	void addFirst(E e);
+
+	void addLast(E e);
+
+	boolean offerFirst(E e);
+
+	boolean offerLast(E e);
+
+	E removeFirst();
+
+	E removeLast();
+
+	E pollFirst();
+
+	E pollLast();
+
+	E getFirst();
+
+	E getLast();
+
+	E peekFirst();
+
+	E peekLast();
+
+	boolean removeFirstOccurrence(Object o);
+
+	boolean removeLastOccurrence(Object o);
+
+}
+
+//A Queue that additionally supports operations that wait for 
+//the queue to become non-empty when retrieving an
+//element, and wait for space to become available in the queue when
+//storing an element.
+interface BlockingQueue<E> extends Queue<E> {
+	//Same as in Queue Interface
+	//Inserts the specified element into queue IMMEDIATELY 
+	//Throws exception in case of failure	
+	boolean add(E e);
+
+	//Same as in Queue Interface
+	//Inserts the specified element into queue IMMEDIATELY 
+	//Returns false in case of failure	
+	boolean offer(E e); //Same as in Queue Interface
+
+	//Inserts the specified element into this queue, waiting 
+	//if necessary for space to become available.
+	void put(E e) throws InterruptedException;
+
+	//waiting up to the specified wait time
+	boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException;
+
+	//waits until element becomes available
+	E take() throws InterruptedException;
+
+	//waits for specified time and returns null if time expires
+	E poll(long timeout, TimeUnit unit) throws InterruptedException;
+
+	int remainingCapacity();
+
+	boolean remove(Object o);
+
+	public boolean contains(Object o);
+
+	int drainTo(Collection<? super E> c);
+
+	int drainTo(Collection<? super E> c, int maxElements);
+}
+
+//The elements of the priority queue are ordered according to their natural ordering
 class PriorityQueue /* implements Queue */{
 	// sorted - natural order
-	//
 
 }
 
+class ArrayDeque /*implements Deque*/{
+
+}
+
+class ArrayBlockingQueue /*implements BlockingQueue*/{
+	//uses Array - optionally-bounded
+}
+
+class LinkedBlockingQueue /*implements BlockingQueue*/{
+	//uses Linked List - optionally-bounded
+	//Linked queues typically have higher throughput than array-based queues but
+	//less predictable performance in most concurrent applications.
+}
+
 // A,C,A,C,E,C,M,D,H,A
 
 // {("A",5),("C",2)}
@@ -218,6 +356,55 @@ public static abstract interface Entry<K, V> {
 	}
 }
 
+// A Map that orders based on the keys. Comparator can be provided at
+// map creation time
+interface SortedMap<K, V> extends Map<K, V> {
+	Comparator<? super K> comparator();
+
+	SortedMap<K, V> subMap(K fromKey, K toKey);
+
+	SortedMap<K, V> headMap(K toKey);
+
+	SortedMap<K, V> tailMap(K fromKey);
+
+	K firstKey();
+
+	K lastKey();
+}
+
+//A SortedMap extended with navigation methods reporting closest matches for given search targets.
+interface NavigableMap<K, V> extends SortedMap<K, V> {
+	Map.Entry<K, V> lowerEntry(K key);
+
+	K lowerKey(K key);
+
+	Map.Entry<K, V> floorEntry(K key);
+
+	K floorKey(K key);
+
+	Map.Entry<K, V> ceilingEntry(K key);
+
+	K ceilingKey(K key);
+
+	Map.Entry<K, V> higherEntry(K key);
+
+	K higherKey(K key);
+
+	Map.Entry<K, V> firstEntry();
+
+	Map.Entry<K, V> lastEntry();
+
+	Map.Entry<K, V> pollFirstEntry();
+
+	Map.Entry<K, V> pollLastEntry();
+
+	NavigableMap<K, V> descendingMap();
+
+	NavigableSet<K> navigableKeySet();
+
+	NavigableSet<K> descendingKeySet();
+}
+
 class HashMap /* implements Map */{
 	// unsorted, unordered
 	// key's hashCode() is used