Java Collection

/* This class implements the Comparable interface which uses as a comparison between two objects.
*   Class has override the compareTo() method
*/
class StudentComparableDemo implements Comparable<StudentComparableDemo>{  
int rollno;  
String name;  
int age;  
StudentComparableDemo(int rollno,String name,int age){  
this.rollno=rollno;  
this.name=name;  
this.age=age;  
}  
//This method performs the comparison of object of Student using the attribute the age which compares with the age of other student object.
public int compareTo(StudentComparableDemo st){  
if(age==st.age)   // If age of both the object is same it will return 0
return 0;  
else if(age>st.age)  
return 1;  
else  
return -1;  
}  
}  

import java.util.*;
import java.lang.*;
import java.io.*;
// This class to represent an Employee domain object which eventually works store the employee domain information.
class Employee
{
   int empid;
   String name, address;
   // Constructor
   public Employee(int empid, String name,
                              String address)
   {
       this.empid = empid;
       this.name = name;
       this.address = address;
   }
   // Used to print Employee details in main()
   public String toString()
   {
       return this.empid + " " + this.name +
                          " " + this.address;
   }
}
/* This classes responsible for performing the compare and sorting the employee result according to the empid
*/
class SortbyId implements CompemployeeListator<Employee>
{
   // Used for sorting in ascending order of
   // roll number
   public int compemployeeListe(Employee a, Employee b)
   {
       return a.empid - b.empid;
   }
}



/* This classes responsible to performs the compare and sorting the employee result according to the empid
*/  
class Sortbyname implements CompemployeeListator<Employee>
{
   // Used for sorting in ascending order of
   // roll name
   public int compemployeeListe(Employee a, Employee b)
   {
       return a.name.compemployeeListeTo(b.name);
   }
}
// The Driver class perform the operation on sorting the employee object
class Main
{
   public static void main (String[] employeeListgs)
   {
       employeeListrayList<Employee> employeeList = new employeeListrayList<Employee>();
       employeeList.add(new Employee(111, "bbbb", "london"));
       employeeList.add(new Employee(131, "aaaa", "nyc"));
       employeeList.add(new Employee(121, "cccc", "jaipur"));
       System.out.println("Unsorted");
       for (int i=0; i<employeeList.size(); i++)
           System.out.println(employeeList.get(i));

       Collections.sort(employeeList, new SortbyId());
       System.out.println("\nSorted by empid");
       for (int i=0; i<employeeList.size(); i++)
           System.out.println(employeeList.get(i));
       Collections.sort(employeeList, new Sortbyname());
       System.out.println("\nSorted by name");
       for (int i=0; i<employeeList.size(); i++)
           System.out.println(employeeList.get(i));
   }
}

public class EnumerationIteration
{
 public static void main(String args[])
 {
     Vector Barista = new Vector();
   Barista.add("Chipotele"); Barista.add("Starbucks"); Barista.add("Dunkin Donuts");
// Creating the enumeration from Vector
   Enumeration enumerate = Barista.elements();
// Traversing to the elements using hasMoreElements() method.
   while(enumerate.hasMoreElements())
   {
    //
     System.out.println(enumerate.nextElement());
   }
 }
}
// Below is the code snippet for Iterator
import java.util.*;
public class EnumerationIteration
{
 public static void main(String args[])
 {
   Vector foodChain = new Vector();
   foodChain.add("Mc Donalds"); foodChain.add("Subway"); foodChain.add("Chipotele");
   System.out.println("USA Food shops:");
   Iterator it = foodChain.iterator();
   while(it.hasNext())
   {
     System.out.println(it.next());
   }
 }
}

import java.util.Stack;
public class StackExample {
   public static void main(String a[]){
       Stack<Integer> stack = new Stack<>();
       System.out.println("Empty stack : "  + stack);
// Checking whether the stack is empty?
       System.out.println("Empty stack : "  + stack.isEmpty());
       // Exception in thread "main" java.util.EmptyStackException
// Adding the elements in the queue
       stack.push(1001);
       stack.push(1002);
       stack.push(1003);
       stack.push(1004);
       System.out.println("Non-Empty stack : "  + stack);
// Getting the elements from the queue
       System.out.println("Non-Empty stack: Pop Operation : "  + stack.pop());
       System.out.println("Non-Empty stack : After Pop Operation : "  + stack);
// Checking whether the elements in the queue.
       System.out.println("Non-Empty stack : search() Operation : "  + stack.search(1002));
       System.out.println("Non-Empty stack : "  + stack.isEmpty());
   }
}

import java.util.LinkedList;
import java.util.Queue;
public class QueueExample
{
 public static void main(String[] args)
 {
   Queue<Integer> queue = new LinkedList<>();
   // Adds elements {0, 1, 2, 3, 4} to queue
   for (int i=0; i<5; i++)
    queue.add(i);
   // Display contents of the queue.
   System.out.println("Elements of queue-"+q);
   // To remove the head of queue.
   int removedele = queue.remove();
   System.out.println("removed element-" + removedele);
   System.out.println(queue);
   // To view the head of queue
   int head = queue.peek();
   System.out.println("head of queue-" + head);
   // Rest all methods of collection interface,
   // Like size and contains can be used with this
   // implementation.
   int size = queue.size();
   System.out.println("Size of queue-" + size);
 }
}

protected static final class Segment {
 protected int count;
// The count is a counter which update is synchronized
 protected synchronized int getCount() {
   return this.count;
 }
 protected synchronized void synch() {}
}
/** Segment Array declaration **/
public final Segment[] segments = new Segment[32];  

Integer prime = 1; 
WeakReference<Integer> soft = new WeakReference<Integer>(prime);
prime = null;

private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
        V value;
        final int hash;
        Entry<K,V> next;
        /**
         * Creates new entry.
         */
        Entry(Object key, V value,
              ReferenceQueue<Object> queue,
              int hash, Entry<K,V> next) {
            super(key, queue);
            this.value = value;
            this.hash = hash;
            this.next = next;
        }
        @SuppressWarnings("unchecked")
        public K getKey() {
            return (K) WeakHashMap.unmaskNull(get());
        }