ConcurrentLinkedList.java

gehe zur Dokumentation dieser Datei

package de.lathanda.eos.base.util;
 
import java.util.Iterator;
 
public class ConcurrentLinkedList<T>  implements Iterable<T> {
 
    private Node<T> root;
    private Node<T> last;
    private int count;
    public ConcurrentLinkedList() {
        this.root = null;
        this.last = null;
        count = 0;
    }
 
    public synchronized void add(T t) {
        if (last == null) {
            root = new Node<T>(t);
            last = root;
        } else {
            last.next = new Node<T>(t);
            last = last.next;
        }
        count++;
    }
    public synchronized void addFront(T t) {
        if (root == null) {
            root = new Node<T>(t);
            last = root;
        } else {
            root = new Node<T>(t, root.next);
        }
    }
    public synchronized void remove(T t) {
        if (root == null) {
            return;
        } else if (root.t == t) {
            if (root == last) {
                last = null;
                root = null;
            } else {
                root = root.next;
            }
        } else  {
            Node<T> prev = root;
            Node<T> act = root.next;
            while (act != null) {
                if (act.t == t) {
                    prev.next = act.next;
                    if (act == last) {
                        last = prev;
                    }
                    count--;
                    return;
                }
                prev = act;
                act = act.next;
            }
        }
        count--;
    }
    public int getLength() {
        return count;
    }
    @Override
    public Iterator<T> iterator() {
        return new TIterator<T>(root);
    }
 
    public synchronized void clear() {
        root = null;
        last = null;
    }
 
    private static class Node<T> {
        private volatile Node<T> next;
        private T t;
 
        public Node(T t) {
            this.t = t;
        }
        public Node(T t, Node<T> next) {
            this.t= t;
            this.next = next;
        }
    }
 
    private static class TIterator<T> implements Iterator<T> {
        private Node<T> index;
 
        public TIterator(Node<T> index) {
            this.index = index;
        }
 
        @Override
        public boolean hasNext() {
            return index != null;
        }
 
        @Override
        public T next() {
            T next = index.t;
            index = index.next;
            return next;
        }
    }
}