CC-20 : Simulate an Ad carousel using CircularDoubleLinkedList.

Below fully running code can be copied and run on Eclipse or other Java IDEs. Refer the classname in code below. If the class name below is "A", save the code below to a file named A.java before running it. Be sure to try your own test cases to enhance your understanding ! You can also tweak the code to optimize or add enhancements and custom features.

Note: For easier code execution and easier reference, the class below contains code for CircularDoubleLinkedList and DoubleLinkedListNode as internal classes. Ideally both these classes should be separate public classes.

import java.util.Scanner;

public class CircularDoubleLinkedListAdCarousel {

public static void circularSingleLinkedListDisplayAdCarousel() throws Exception{
	CircularDoubleLinkedListAdCarousel carousal=new CircularDoubleLinkedListAdCarousel();
	CircularDoubleLinkedList adCarousel=carousal.new CircularDoubleLinkedList();
 	DoubleLinkedListNode currentAdinCarousel=null;
 	int newAdCounter=0;
 	while (true) {
 	try { 				
 	System.out.println("\n\n Advertisement carousel display menu :");
 	System.out.println();
 	System.out.println("1: Add a new Ad to carousel");
 	System.out.println("2: Display Ad carousel");
 	System.out.println("3: Exit Advertisement carousel display program");
 	System.out.println();
 	System.out.println("Choose an option:\n");
 	int selectedMenuOption=readIntegerFromConsole();
 	switch(selectedMenuOption) {
 	case 1://Add a new Ad
 		newAdCounter++;
 		adCarousel.addLast(newAdCounter);
 		break;		
 	case 2: //Display
 		printAdCarousel(adCarousel);
 		   break;
 	case 3: //Exit the program
 		System.out.println("\nExiting program....\n");
 		return;
 	default: //user has input an option that is not available
 			System.out.print("\n Invalid option selected; please use one of the options given above: ");
 			break;
 	}
 	}catch (Exception exception) {
 		System.out.print("Exception: "+ exception);
 		continue;
 	}	
 	}
}
 	
 	
 // print DoubleLinkList forward direction
 public static void printAdCarousel(CircularDoubleLinkedList adCarousel) throws Exception    {
    DoubleLinkedListNode firstNode=adCarousel.getFirstNode();
    if (firstNode == null) { System.out.println("\n\n AdCarousel empty\n"); return; }
    DoubleLinkedListNode currentNode=adCarousel.getFirstNode();
	System.out.println();
	System.out.println("Displaying Circular Ads Carousel...");
	System.out.println("Each Ad will be displayed for 4 seconds");
	System.out.println("(To stop Ad carousel, close the program manually !");
    do  {
	System.out.println("*************************");
	System.out.print("Current Displayed Ad: Ad");
    System.out.print(currentNode.getNodeData());
	currentNode=currentNode.getNextNode();
    System.out.println();
	System.out.println("**************************");
	System.out.println();
	Thread.sleep(4000);
	} while( true);
}
    
    
public static void main(String[] args) {
	
	try {
		circularSingleLinkedListDisplayAdCarousel();
	}catch (Exception exception) {
		System.out.print("Exception: "+ exception);
		
	}
			
}

public static int readIntegerFromConsole() throws Exception{
	try {
		Scanner in = new Scanner(System.in);
		int intInput = in.nextInt();
		return intInput;
	} catch (Exception e){
		System.out.println("Entered Option was not an integer");
		throw new Exception();
	}
}

class CircularDoubleLinkedList {
	
private DoubleLinkedListNode firstNode=null;

public DoubleLinkedListNode getFirstNode() {
	return firstNode;
}

public void setFirstNode(DoubleLinkedListNode firstNode) {
	this.firstNode = firstNode;
}	

public DoubleLinkedListNode getLastNode() {
	if (firstNode==null) {return null;}
	DoubleLinkedListNode currentNode=firstNode;
	DoubleLinkedListNode prevNode=null;
  	do {
  		prevNode=currentNode;
  		currentNode=currentNode.getNextNode();
  	}while (currentNode !=firstNode);
  	return prevNode;
}
	
public boolean addLast(int data){
	DoubleLinkedListNode node=new DoubleLinkedListNode();
	node.setNodeData(data);
	if (firstNode==null) { 
		firstNode=node; 
		node.setNextNode(node);
		node.setPreviousNode(node);
		return true;
	}
	else {
		DoubleLinkedListNode currentNode=firstNode;
		while (currentNode.getNextNode()!=firstNode) {currentNode=currentNode.getNextNode();}
		node.setPreviousNode(currentNode);	
		node.setNextNode(firstNode);
		currentNode.setNextNode(node);
		firstNode.setPreviousNode(node);
		return true;		
	}
}

public boolean addFirst(int data){
	DoubleLinkedListNode node=new DoubleLinkedListNode();
	node.setNodeData(data);
	if (firstNode==null) { 
		firstNode=node; 
		node.setNextNode(node);
		node.setPreviousNode(node);
		return true;
	}else {
	DoubleLinkedListNode currentNode=firstNode;
	while (currentNode.getNextNode()!=firstNode) {currentNode=currentNode.getNextNode();}
		node.setNextNode(firstNode);
		node.setPreviousNode(currentNode);
		firstNode.setPreviousNode(node);
		firstNode=node; 
		currentNode.setNextNode(node);
		return true;			
	}
}
	
public boolean add(int data, int pos){	
	int size=getSize();
	if ((pos<0) || (pos > size)) { return false;}
	if (pos==0) {
		addFirst(data);
		return true;
	}
	if (pos==size) {
		addLast(data);
		return true;
	}
	if (firstNode==null) { return false;}
	DoubleLinkedListNode node=new DoubleLinkedListNode();
	node.setNodeData(data);
	DoubleLinkedListNode currentNode=firstNode;
	DoubleLinkedListNode prevNode=null;
	int idx=0;
	while (currentNode !=null) {
		  if ((idx==pos)){
		  node.setNextNode(prevNode.getNextNode());
		  prevNode.setNextNode(node);
		  //setup previous node linkages
		  node.getNextNode().setPreviousNode(node);
		  node.setPreviousNode(prevNode);
		  return true;
	}
    prevNode=currentNode;
	currentNode=currentNode.getNextNode();
	idx++;
	}  	
    return false;  	
}	
	
public int getSize() {
	if (firstNode==null) { return 0;}
	DoubleLinkedListNode currentNode=firstNode;
	int idx=0;
	do {
	  	currentNode=currentNode.getNextNode();
	  	idx++;
	}while (currentNode !=firstNode);
	return idx;
}
	
	
public boolean removeFirst() {
	if (firstNode == null) { return false; }
	if (firstNode.getNextNode()==firstNode) {
		firstNode=null; 
		return true;
	}
	DoubleLinkedListNode currentNode=firstNode;
	while (currentNode.getNextNode()!=firstNode) {currentNode=currentNode.getNextNode();}
	firstNode=firstNode.getNextNode(); 
	firstNode.setPreviousNode(currentNode);
	currentNode.setNextNode(firstNode);
	return true;
}		

public boolean removeLast() {
	if (firstNode == null) { return false; }
	DoubleLinkedListNode currentNode=firstNode;
	DoubleLinkedListNode prevNode=null;
	do {
		if (currentNode.getNextNode()==firstNode) {
			if (prevNode==null) {
				firstNode=null;
				return true;
			}
  			prevNode.setNextNode(firstNode);
  			firstNode.setPreviousNode(prevNode);
  			currentNode.setPreviousNode(firstNode);
  			return true;
		}
		prevNode=currentNode;
  		currentNode=currentNode.getNextNode();    		
  	}	while (currentNode !=null);
	return false;
}

public boolean remove(int data){	
	DoubleLinkedListNode currentNode=firstNode;
	DoubleLinkedListNode prevNode=null;
  	 do {
  		if (currentNode.getNodeData() == data) {
  			if (prevNode==null) {
  				removeFirst();
  				return true;
  			}
  			if (currentNode.getNextNode()==firstNode) {
  				removeLast();
  				return true;
  			}
  			prevNode.setNextNode(currentNode.getNextNode());
  			prevNode.getNextNode().setPreviousNode(prevNode);
  			return true;
  		}
  		prevNode=currentNode;
  		currentNode=currentNode.getNextNode();  		
  	}  	while (currentNode !=firstNode);
  	return false;  	
 }	

public boolean removeAtPos(int pos){	
	if (firstNode == null) { return false; }
	DoubleLinkedListNode currentNode=firstNode;
	DoubleLinkedListNode prevNode=null;
  	int idx=0;
  	do {
  		if (idx==pos) {
  			if (prevNode==null) {
  				removeFirst();
  				return true;
  			}
  			if (currentNode.getNextNode()==null) {
  				removeLast();
  				return true;
  			}
  			prevNode.setNextNode(currentNode.getNextNode());
  			return true;
  		}
  		prevNode=currentNode;
  		currentNode=currentNode.getNextNode();  
  		idx++;
  	} while (currentNode !=firstNode); 	
  	return false;  	  	
}		

public int get(int idx) {
	if (firstNode == null) { return Integer.MIN_VALUE; }
	DoubleLinkedListNode currentNode=firstNode;
  	int currIdx=0;
  	do {
  		if (currIdx==idx) {return currentNode.getNodeData();}
  		currentNode=currentNode.getNextNode();
  		currIdx++;
  	} while (currentNode !=firstNode);
  	return Integer.MIN_VALUE;
}

public void traverseForward() {
	DoubleLinkedListNode currentNode=firstNode;
	do {
  		System.out.println(currentNode.getNodeData());
  		currentNode=currentNode.getNextNode();
  	}while (currentNode !=firstNode);
}
			
// print CircularDoubleLinkList forward direction
public void printDoubleLinkListForwardDirection() throws Exception    {
	// Case 1: The Linked list is empty !!
	if (firstNode == null) { System.out.println("CircularDoubleLinkedlist empty"); return; }
	// Case 2: Print Circular Double LinkedList node by node (first to last)
	DoubleLinkedListNode currentNode=firstNode;
	System.out.println();
	System.out.println("*************************************************");
	System.out.print("Circular DoubleLinkedList nodes (first node to last node): ");
	do  {
			System.out.print(currentNode.getNodeData());
		   	 if (currentNode.getNextNode()!=firstNode)  System.out.print(" -> ");
			currentNode=currentNode.getNextNode();
			
		} while( currentNode != firstNode);
		System.out.print("<last node points to first node>");
		System.out.println();
		System.out.println("*************************************************");
			System.out.println();
			Thread.sleep(2000);
			return;
}
    
 // print CircularDoubleLinkList backward direction
public void printDoubleLinkListBackwardDirection() throws Exception    {
	// Case 1: The Linked list is empty !!
	if (firstNode == null) { System.out.println("Circular Double Linked list empty"); return; }
	// Case 2: Print Circular Double LinkedList node by node (last to first)
	// This while loop executes till we reach last node in the LinkedList
	DoubleLinkedListNode currentNode=firstNode;
	while (currentNode.getNextNode()!=firstNode) {currentNode=currentNode.getNextNode();}
	//currentNode is at end of LinkedList	
	System.out.println();
	System.out.println("*************************************************");
	System.out.print("DoubleLinkedList nodes (last node to first node): ");
	do  {
		    System.out.print(currentNode.getNodeData());
		    if (currentNode != firstNode)  System.out.print(" -> ");
			currentNode=currentNode.getPreviousNode();
			
		} while( currentNode != firstNode.getPreviousNode());
		System.out.print("<first node points to last node>");
		System.out.println();
		System.out.println("*************************************************");
		System.out.println();
		Thread.sleep(2000);
		return;
}
}
	
class DoubleLinkedListNode  {
	private DoubleLinkedListNode nextNode=null;
	private DoubleLinkedListNode previousNode=null;
	
	private int nodeData=0;

	public DoubleLinkedListNode getNextNode() {
		return nextNode;
	}
	public void setNextNode(DoubleLinkedListNode nextNode) {
		this.nextNode = nextNode;
	}
	public DoubleLinkedListNode getPreviousNode() {
		return previousNode;
	}
	public void setPreviousNode(DoubleLinkedListNode previousNode) {
		this.previousNode = previousNode;
	}
	public int getNodeData() {
		return nodeData;
	}
	public void setNodeData(int nodeData) {
		this.nodeData = nodeData;
	}
}	
	
	
}