Sorted map creation is explained here.
SortedMap mapA = new TreeMap();
Comparator comparator = new MyComparator();
SortedMap mapB = new TreeMap(comparator);

Map<String, MyObject> map = new HashSet<String, MyObject>();

for(MyObject anObject : map.values()){
   //do someting to anObject...
}
for(String key : map.keySet()){
   MyObject value = map.get(key);
   //do something to value
}

Map mapA = new HashMap();
mapA.put("key1", "element 1");
mapA.put("key2", "element 2");
mapA.put("key3", "element 3");

String element1 = (String) mapA.get("key1");

// key iterator
Iterator iterator = mapA.keySet().iterator();
// value iterator
Iterator iterator = mapA.values();
Also you can iterate the keys and get the corresponding values based on these keys.
Iterator iterator = mapA.keySet().iterator();
while(iterator.hasNext(){
  Object key   = iterator.next();
  Object value = mapA.get(key);
}
//access via new for-loop
for(Object key : mapA.keySet()) {
    Object value = mapA.get(key);
}

Map mapA = new HashMap();
Map mapB = new TreeMap();

HashMap<String, Object> myMap = new HashMap<String, Object>();
Map<String, Object> myMap = new HashMap<String, Object>();

import java.util.*;
public class MyMapDemo {
	public static void main(String[] args) {
	Map m1 = new HashMap();
	m1.put("Ankit", "8");
	m1.put("Kapil", "31");
	m1.put("Saurabh", "12");
	m1.put("Apoorva", "14");
	System.out.println();
	System.out.println("Elements of Map");
	System.out.print(m1);
	}
}

Stack myStack = new Stack();
myStack.push("1");
myStack.push("2");
myStack.push("3");
//look at top object ("3"), without taking it off the stack.    
Object topObj = stack.peek();
Object obj3 = stack.pop(); //the string "3" is at the top of the stack.
Object obj2 = stack.pop(); //the string "2" is at the top of the stack.
Object obj1 = stack.pop(); //the string "1" is at the top of the stack.

Stack myStack = new Stack();
myStack.push("1");
myStack.push("2");
myStack.push("3");
int index = myStack.search("3");     //index = 3

import java.io.*;
import java.util.*;

public class StackImplement{
  Stack<Integer> stack;
  String str;
  int num, n;
  public static void main(String[] args){
  StackImplement q = new StackImplement();
  }
  public StackImplement(){
  try{
  stack = new Stack<Integer>();
  InputStreamReader ir = new InputStreamReader(System.in);
  BufferedReader bf = new BufferedReader(ir);
  System.out.print("Enter number of elements : ");
  str = bf.readLine();
  num = Integer.parseInt(str);
  for(int i = 1; i <= num; i++){
  System.out.print("Enter elements : ");
  str = bf.readLine();
  n = Integer.parseInt(str);
  stack.push(n);
  }
  }
  catch(IOException e){}
  System.out.print("Retrieved elements from the stack : ");
  while (!stack.empty()){
  System.out.print(stack.pop() + "  ");
  }
  }
}

import java.util.Stack;

public class MyStackDemo
{
        public static void main(String args[])
        {
                // Create a new, empty stack
                Stack lifo = new Stack();

                // Let's add some items to it
                for (int i = 1; i <= 10; i++)
                {
                        lifo.push ( new Integer(i) );
                }

                // Last in first out means reverse order
                while ( !lifo.empty() )
                {
                        System.out.print ( lifo.pop() );
                        System.out.print ( ',' );
                }

                // Empty, let's lift off!
                System.out.println (" LIFT-OFF!");
        }

}

Deque dequeA = new LinkedList();
Deque dequeB = new ArrayDeque();

Queue myQueue = new LinkedList();
myQueue.add("element 1");
myQueue.add("element 2");
myQueue.add("element 3");

Object firstElement = myQueue.element();

Queue myQueue = new LinkedList();
myQueue.add("element 0");
myQueue.add("element 1");
myQueue.add("element 2");

//access via Iterator
Iterator iterator = myQueue.iterator();
while(iterator.hasNext(){
  String element = (String) iterator.next();
}

//access via new for-loop
for(Object object : myQueue) {
    String element = (String) object;
}

Queue queueA = new LinkedList();
Queue queueB = new PriorityQueue();

import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;

public class QueueTesting {

    public static void main(String[] args) {

        Queue<String> myQueue=new LinkedList<String>();

        myQueue.add("b");
        myQueue.add("a");
        myQueue.add("c");
        myQueue.add("e");
        myQueue.add("d");

        Iterator it= myQueue.iterator();

        System.out.println("Initial Size of Queue :"+ myQueue.size());

        while(it.hasNext())
        {
            String iteratorValue=(String)it.next();
            System.out.println("Queue Next Value :"+iteratorValue);
        }

        // get value and does not remove element from queue
        System.out.println("Queue peek :"+ myQueue.peek());

        // get first value and remove that object from queue
        System.out.println("Queue poll :"+ myQueue.poll());

        System.out.println("Final Size of Queue :"+ myQueue.size());
    }
}

List listA = new ArrayList();
List listB = new LinkedList();
List listC = new Vector();
List listD = new Stack();

public class TestClass {
  public static void main(String[] args) {
    int  len = 100000;
    LinkedList linkedLst = new LinkedList(); 
    ArrayList  arrayLst = new ArrayList();
    for (int m =0; m!= len; m++) {
      int x = (int)Math.random();
      linkedLst.add(x);
      arrayLst.add(x);
    }
    
    long t = System.currentTimeMillis();
    for (int i = 0; i!=len; i++) {
      linkedLst.get(i);
    }
    t = System.currentTimeMillis() - t;
    System.out.println("LinkedList -- get(index) takes "+t +"(ms)");

    t = System.currentTimeMillis();
    for  (Iterator itr = linkedLst.iterator();
      itr.hasNext();) {
      itr.next();     		
    }		
    t = System.currentTimeMillis() - t;
    System.out.println("LinkedList -- Iterator takes "+t +"(ms)");
    
    t = System.currentTimeMillis();
    for (int i = 0; i!=len; i++) {
      arrayLst.get(i);
    }
    t = System.currentTimeMillis() - t;
    System.out.println("ArrayList -- get(index) takes "+t +"(ms)");

    t = System.currentTimeMillis();
    for  (Iterator itr = arrayLst.iterator();
           itr.hasNext();) {
      itr.next();     		
    }		
    t = System.currentTimeMillis() - t;
    System.out.println("ArrayList -- Iterator takes "+t +"(ms)");
		
  }
}

theList.removeLast();
theList.remove(0);
theList.removeFirst();
theList.removeFirst();

import java.util.*;
public class TestLinkedList
{
public static void main(String[] args)
{
int pause;
String temp;
LinkedList theList = new LinkedList();
theList.add("1");
theList.add(0, "2");
theList.addFirst("3");
theList.addLast("4");
System.out.println("Size: "+theList.size());
System.out.println("Element 0: "+theList.get(0));
temp = theList.get(1);
System.out.println("Element 1: "+temp);
System.out.println("Size :"+ theList.size());
System.out.println("First :"+ theList.getFirst());
System.out.println("Last :"+ theList.getLast());
System.out.println("Size yet again: "+theList.size());
theList.removeFirst();
System.out.println("Size yet again: "+theList.size());
theList.removeLast();
theList.remove(0);
theList.removeFirst();
System.out.println("Empty Size: "+theList.size());
for(int x=0; x<100; x++) {
theList.add(""+x);
}
System.out.println("Loop Size :"+ theList.size());
for(int x=100; x>0; x--) {
theList.removeLast();
}
System.out.println("Empty Size: "+theList.size());
}
}

System.out.println(MyList.size());

System.out.println(MyList.get(0));
//or to store the value first
temp = MyList.get(0);
System.out.println(temp);

MyList.add("1");
//or
MyList.add(varName);

MyList.add(0, "2");
//or
MyList.add(0, varName);

MyList.addFirst("3");
MyList.addLast("4");