package einfuehrung.knodenUndListeKopie;
import java.util.Iterator;
import java.util.NoSuchElementException;
public class List<T> {
    private class ListIterator<K> implements Iterator<T> {
        private Node<T> node = null;
        public ListIterator() {
            node = head;
        }
        @Override
        public boolean hasNext() {
            return node.getNext() != null;
        }
        @Override
        public T next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            node = node.getNext();
            T obj = node.getObject();
            return obj;
        }
    }
    public Iterator<T> iterator() {
        ListIterator<T> iter = new ListIterator<T>();
        return iter;
    }
    private Node<T> head;
    public List() {
        this.head = new Node<T>();
    }
    public Node<T> getHead() {
        return head;
    }
    public void setHead(Node<T> head) {
        this.head = head;
    }
    public boolean isEmpty() {
        return head.getNext() == null;
    }
    public void addFirst(T element) {
        Node<T> node = new Node<T>();
        Node<T> nextNode = head.getNext();
        node.setObject(element);
        node.setNext(nextNode);
        head.setNext(node);
    }
    public void addLast(T element) {
        Node<T> node = new Node<T>();
        Node<T> lastNode = head;
        while (lastNode.getNext() != null) {
            lastNode = lastNode.getNext();
        }
        lastNode.setNext(node);
        node.setNext(null);
        node.setObject(element);
    }
    public Object removeFirst() {
        Object solution;
        if (isEmpty()) {
            solution = null;
        }
        Node<T> node = head.getNext();
        Node<T> nextNode = node.getNext();
        solution = node.getObject();
        head.setNext(nextNode);
        return solution;
    }
    public Object removeLast() {
        Object solution;
        if (isEmpty()) {
            solution = null;
        }
        Node<T> beforeLastNode = head;
        Node<T> lastNode;
        while (beforeLastNode.getNext().getNext() != null) {
            beforeLastNode = beforeLastNode.getNext();
        }
        lastNode = beforeLastNode.getNext();
        solution = lastNode.getObject();
        beforeLastNode.setNext(null);
        return solution;
    }
    /**
     * It does not delete the node, where the element is saved.
     * 
     * @return first element of list
     */
    public Object getFirstElement() {
        return head.getNext().getObject();
    }
}

package einfuehrung.knodenUndListeKopie;
import java.util.Collection;
public class Node<T extends Collection<?>> {
    private Node<T> next;
    private T object;
    public Node() {
    }
    public Node(Node<T> next, T object) {
        this.next = next;
        this.object = object;
    }
    public Node<T> getNext() {
        return next;
    }
    public void setNext(Node<T> next) {
        this.next = next;
    }
    public T getObject() {
        return object;
    }
    public void setObject(T object) {
        this.object = object;
    }
    public int countAllElements() {
        int solution;
        solution = object.size();
        if (this.next != null) {
            solution += this.next.countAllElements();
        }
        return solution;
    }
}

public int countAllElements(ToIntFunction<? super T> counter) {
    int solution = counter.apply(object);
    if (this.next != null) {
        solution += this.next.countAllElements(counter);
    }   
    return solution;
}