Use Java for this maven project as well as junit testing

DO NOT add any folders or change the structure of the project in anyway. DO NOT alter the pom.xml file. Create a generic abstract class called Generic List head (this is the head of the list and should be private). int length (the length of the list and should be private) This class should include the following methods: print(): prints the items of the list, one value per line. If the list is empty, print "Empty List". add(l data): adds the value to the list. This method is abstract since the implementation depends on what the data structure is. public I delete(); returns the first value of the list and deletes the node. If the list is empty, return null. public ArrayList dumpList(): this method stores and returns all values currently in the list into an ArrayList and returns it. At the end of this method, your list should be empty. getLength() setLength() getHead() setHead(), these are getters/setters for private data members head and length. This class should also define a generic inner class Node: It will include two fields: T data and Nodenext; ***This class encapsulates a linked list. Defining a Node class and providing two methods that a queue and stack have in common while leaving adding a node to each implementation that inherits from it.*** Create two more classes GenericQueue and Generic Stack. They both should inherit from GenericList. The constructors for each class will take one parameter. That parameter will be a value that will go in the first node of the list encapsulated by each instance of the class. Each constructor should initialize the linked list head, with the value passed in by the constructor. Each class should also implement the method add(l data), Generic Queue will add to the back of the list while Generic Stack will add to the front. Each class must also keep track of the length of it's list using the length data field defined in the abstract class. GenericQueue will have the methods enqueue(l data) and public i dequeue() which will call the methods add(data) and delete() respectively. Enqueue and dequeue merely call add(l data) and delete(). The reason for this is that a user would expect these calls to be implemented in each of those data structures. You will do the same with Generic Stack Generic Stack will have the methods push(I data) and public I pop() which will call the methods add(data) and delete() respectively. Once implemented, you should be able to create instances of both GenericQueue and Generic Stack in main with most primitive wrapper classes. You should be able to add and delete nodes to each data structure instance as well as print out the entire list and check for the length of the list. You must follow this implementation: meaning you can not add any additional data fields or classes. You may add getters/setters as need be. Implementing Iterator Design Pattern: You are to create an interface called CreateIterator. It will have one abstract method: Iterator createIterator(). Since both GenericQueue and Generic Stack classes iterate through a list the same way, you will want to implement this interface in GenericList. You must also create a class to contain logic for iterating through your data structure. Call this class GLiterator. GLiterator should be a generic class since it provides the logic to iterate through a generic stack and queue. It should implement the java interface Iterator (java.util.Iterator). You will have to implement two inherited methods: public boolean hasNext(), checks to see if there is another value in the data structure and returns true or false, and public i next(), returns the current value in the data structure and advances to the next item. You are expected to fully comment your code and use good coding practices. DO NOT add any folders or change the structure of the project in anyway. DO NOT alter the pom.xml file. Create a generic abstract class called Generic List head (this is the head of the list and should be private). int length (the length of the list and should be private) This class should include the following methods: print(): prints the items of the list, one value per line. If the list is empty, print "Empty List". add(l data): adds the value to the list. This method is abstract since the implementation depends on what the data structure is. public I delete(); returns the first value of the list and deletes the node. If the list is empty, return null. public ArrayList dumpList(): this method stores and returns all values currently in the list into an ArrayList and returns it. At the end of this method, your list should be empty. getLength() setLength() getHead() setHead(), these are getters/setters for private data members head and length. This class should also define a generic inner class Node: It will include two fields: T data and Nodenext; ***This class encapsulates a linked list. Defining a Node class and providing two methods that a queue and stack have in common while leaving adding a node to each implementation that inherits from it.*** Create two more classes GenericQueue and Generic Stack. They both should inherit from GenericList. The constructors for each class will take one parameter. That parameter will be a value that will go in the first node of the list encapsulated by each instance of the class. Each constructor should initialize the linked list head, with the value passed in by the constructor. Each class should also implement the method add(l data), Generic Queue will add to the back of the list while Generic Stack will add to the front. Each class must also keep track of the length of it's list using the length data field defined in the abstract class. GenericQueue will have the methods enqueue(l data) and public i dequeue() which will call the methods add(data) and delete() respectively. Enqueue and dequeue merely call add(l data) and delete(). The reason for this is that a user would expect these calls to be implemented in each of those data structures. You will do the same with Generic Stack Generic Stack will have the methods push(I data) and public I pop() which will call the methods add(data) and delete() respectively. Once implemented, you should be able to create instances of both GenericQueue and Generic Stack in main with most primitive wrapper classes. You should be able to add and delete nodes to each data structure instance as well as print out the entire list and check for the length of the list. You must follow this implementation: meaning you can not add any additional data fields or classes. You may add getters/setters as need be. Implementing Iterator Design Pattern: You are to create an interface called CreateIterator. It will have one abstract method: Iterator createIterator(). Since both GenericQueue and Generic Stack classes iterate through a list the same way, you will want to implement this interface in GenericList. You must also create a class to contain logic for iterating through your data structure. Call this class GLiterator. GLiterator should be a generic class since it provides the logic to iterate through a generic stack and queue. It should implement the java interface Iterator (java.util.Iterator). You will have to implement two inherited methods: public boolean hasNext(), checks to see if there is another value in the data structure and returns true or false, and public i next(), returns the current value in the data structure and advances to the next item. You are expected to fully comment your code and use good coding practices