Question

Part I:

Create a doubly linked circular list class named LinkedItemList that implements the following interface:

/**

* An ordered list of items.

*/

public interface ItemList<E> {

     /**

      * Append an item to the end of the list

      *

      * @param item – item to be appended

      */

public void append(E item);

     /**

      * Insert an item at a specified index position

      *

      * @param item – item to be inserted

       * @param index – index position where to insert the item

      * @throw IndexOutOfBoundsException if index is < 0 or > no of items

      */

public void insert(E item, int index);

/**

      * Return an item at a specified index

      *

      * @param index – index of the item to return

      * @return the item at the specified index

      * @throw IndexOutOfBoundsException if index is < 0 or >= no of items

      */

public E get(int index);

/**

      * Remove an item at a specified index

      *

      * @param index – index of the item to be removed

      * @return the removed item

      * @throw IndexOutOfBoundsException if index is < 0 or >= no of items

      */

public E removeAtIndex (int index);

/**

* Return the number of items currently in the list

*

* @return the number of items in the list

*/

public int size();

/**

* Determine if the list is empty

*

* @return true if the list is empty, otherwise false

*/

public boolean isEmpty();

/**

* Clear the list. The list becomes empty

*

*/

public void clear();

}

You will need the appropriate constructors. In addition, you may also implement other methods that may be useful for the assignment (where possible define code in just one place).

Part II:

Write JUnit test program to thoroughly test all of the methods of your LinkedItemList class

Additional Requirements:

The LinkedItemList must be implemented as a doubly linked circular list with a dummy node in place of a first node and last node reference variables.

Provide a fast implementation for append(), e.g., does not need to walk the list to get to the end.

Define and use a private method appendAfter(Node node, E item) which adds a Node to the linked list for the item. Call appendAfter from the append and insert methods. The append and insert methods must not directly create a node.

Define and use a private method removeNode(Node node) which removes a Node from the linked list. Call removeNode from the removeAtIndex method. The removeAtIndex method must not directly remove a node.

Define and use a private method getNode(int index) which returns a node at a given index position. Use getNode in the get, removeAtIndex, and insert methods

Provide a fast implementation for size(), e.g., does not need to walk the list to count the number of items

Answer 1

==========>ItemList<E>.java

package doublelnkdlst;

public interface ItemList<E> {

public void clean();

public void insrt(E item, int index);

public bool Empty();

public E clearAtIndex(int index);

public void apnd(E item);

public int size();

public E get(int index);

}

=======>LinkedItemList<E>.java

package doublelnkdlst;

public class LinkedItemList<E> implements ItemList<E> {

private Node head;

private Node tail;

private int size;

private class Node {

E item;

Node next;

Node prev;

public Node(E item, Node next, Node prev) {

this.item = item;

this.next = next;

this.prev = prev;

}

}

@Override

public void apnd(E item) {

Node tmp = new Node(item, head, null);

if (head != null) {

head.prev = tmp;

}

head = tmp;

if (tail == null) {

tail = tmp;

}

size++;

}

@Override

public void insrt(E item, int index) {

if (index < 0 && index >= size)

throw new IndexOutOfBoundsException();

Node current = head;

Node previous = null;

while (index >= 0) {

previous = current;

current = current.next;

index--;

}

Node node = new Node(item, head, null);

node.next = current;

node.prev = previous;

current.prev = node;

if (previous != null) {

previous.next = node;

}

if (index == 1)

head = node;

}

@Override

public E get(int index) {

if (index < 0 && index >= size)

throw new IndexOutOfBoundsException();

Node temp = head;

while (index > 0) {

temp = temp.next;

index--;

}

return temp.item;

}

@Override

public E clearAtIndex(int index) {

if (index < 0 && index >= size)

throw new IndexOutOfBoundsException();

Node current = head;

Node previous = null;

while (index > 0) {

previous = current;

current = current.next;

index--;

}

if (previous != null) {

previous.next = current.next;

if (current.next != null)

current.next.prev = previous;

}

else {

head = current.next;

head.prev = null;

}

return current.item;

}

@Override

public int size() {

return size;

}

@Override

public bool Empty() {

if (size == 0) {

return true;

}

return false;

}

@Override

public void clean() {

head = null;

size = 0;

}

}

============>Junit test case class

package doublelnkdlst;

import org.junit.runners.JUnit4;

import junit.framework.Assert;

import org.junit.Test;

import org.junit.runner.RunWith;

@RunWith(JUnit4.class)

public class TestLinkedItemList {

@Test

public void testInsrtAndGet() {

ItemList<Integer> list = new LinkedItemList<>();

list.apnd(1);

list.apnd(2);

list.apnd(3);

Assert.assertEquals(list.get(0), Integer.valueOf(3));

Assert.assertEquals(list.get(1), Integer.valueOf(2));

Assert.assertEquals(list.get(2), Integer.valueOf(1));

}

@Test

public void testclearAtIndex() {

ItemList<Integer> list = new LinkedItemList<>();

list.apnd(1);

list.apnd(2);

list.apnd(3);

Assert.assertEquals(list.clearAtIndex(0), Integer.valueOf(3));

Assert.assertEquals(list.clearAtIndex(1), Integer.valueOf(1));

}

@Test

public void testCleanAllAndEmpty() {

ItemList<Integer> list = new LinkedItemList<>();

list.apnd(1);

list.apnd(2);

list.apnd(3);

list.clean();

Assert.assertEquals(Bool.valueOf(list.Empty()), Bool.valueOf(true));

}}