Linked List

Item Wrapper

public class MyLinkedNode<E> {

	private E item;
	private MyLinkedNode<E> next;
	
	public MyLinkedNode(E item) {
		this.item = item;
	}

	public E getItem() {
		return item;
	}

	public MyLinkedNode<E> getNext() {
		return next;
	}

	public void setNext(MyLinkedNode<E> next) {
		this.next = next;
	}

	@Override
	public String toString() {
		return String.format("MyNode [item=%s]", item);
	}
	
}

Item Container

public class MyLinkedList<E> {

	private MyLinkedNode<E> head;
	private int size;

	public int getSize() {
		return size;
	}

	public MyLinkedNode<E> find(E item) {

		MyLinkedNode<E> search = head;
		while (search != null) {

			if (search.getItem().equals(item)) {
				break;
			}
			search = search.getNext();
		}
		return search;
	}

	public MyLinkedNode<E> getItemByIdx(int index) {

		if (index < 0)
			return null;

		MyLinkedNode<E> search = head;
		for (int i = 0; i < index; i++) {
			search = search.getNext();
			if (search == null)
				break;
		}

		return search;
	}

	public void addFirst(E newItem) {

		if (newItem == null)
			return;

		MyLinkedNode<E> newNode = new MyLinkedNode<>(newItem);

		if (head != null) {
			newNode.setNext(head);
		}

		head = newNode;

		size++;
	}

	public void addAfter(E prev, E newItem) {

		if (prev == null)
			return;

		if (newItem == null)
			return;

		MyLinkedNode<E> newNode = new MyLinkedNode<>(newItem);
		MyLinkedNode<E> search = find(prev);
		if (search != null) {
			newNode.setNext(search.getNext());
			search.setNext(newNode);
			size++;
		}

	}

	public void addByIndex(int index, E newItem) {

		if (index < 0)
			return;

		if (index > size)
			return;

		if (index == 0) {
			addFirst(newItem);
		} else {

			MyLinkedNode<E> prevFoundItem = getItemByIdx(index - 1);
			if (prevFoundItem == null)
				return;

			addAfter(prevFoundItem.getItem(), newItem);
		}

	}
	
	public void removeFirst() {
		if(head != null) {
			head = head.getNext();
			size--;
		}
	}
	
	public void removeAfter(E prev) {

		if (prev == null)
			return;

		MyLinkedNode<E> search = find(prev);
		if (search == null || search.getNext() == null) {
			return;
		}
		
		search.setNext(search.getNext().getNext());
		size--;

	}
	
	public void removeByIndex(int index) {

		if (index < 0)
			return;

		if (index >= size)
			return;

		if (index == 0) {
			
			removeFirst();
			
		} else {

			MyLinkedNode<E> prevFoundItem = getItemByIdx(index - 1);
			if (prevFoundItem == null)
				return;

			removeAfter(prevFoundItem.getItem());
		}

	}
	
	public void removeItem(E item) {

		if (item == null)
			return;
		
		MyLinkedNode<E> search = head;
		MyLinkedNode<E> searchPrev = null;
		
		while (search != null) {

			if (search.getItem().equals(item)) {
				break;
			}
			searchPrev = search;
			search = search.getNext();
		}
		
		if(search == null)
			return;
		
		if(searchPrev == null) {
			removeFirst();
			return;
		}
		
		removeAfter(searchPrev.getItem());

	}
	
	@Override
	public String toString() {

		StringBuilder builder = new StringBuilder();

		MyLinkedNode<E> search = head;
		while (search != null) {
			builder.append(search.toString());
			builder.append("\n");
			search = search.getNext();
		}

		builder.append("total size = " + size);

		return builder.toString();
	}

}