java - 有没有像 Observable ConcurrentLinkedDeque 这样的东西？

Question

在我的代码中，我需要一个 ConcurrentLinkedDeque，但我想将此双向双端队列绑定(bind)到 JavaFX 中的 TableView，或者至少将双端队列的大小绑定(bind)到 PieChart，执行此类操作的常见方法是什么。是否有像 ObservableConcurrentLinkedDeque 这样的东西我可以使用而不是 ConcurrentLinkedDeque 并直接绑定(bind)到 TableView？

Answer 1

JavaFX 库中没有这样的实现。

请注意，实现任何类型的并发集合用作 TableView(或绑定(bind)到其状态的任何其他 JavaFX 节点)的后备列表确实没有意义。一旦您使用它作为 UI 节点的支持数据，它就只能从 JavaFX 线程访问，因此使其线程安全是多余的。因此，您只需要求一个可观察列表，它也是一个 Deque。

为此，您可以子类化 ModifiableObservableListBase ，将其委托(delegate)给 LinkedList，并实现 Deque，同时将这些方法委托(delegate)给 LinkedList。您只需要在调用修改列表的 Deque 方法时小心触发更改即可。所以类似:

import java.util.Deque;
import java.util.Iterator;
import java.util.LinkedList;

import javafx.collections.ModifiableObservableListBase;


public class ObservableLinkedList<T> extends ModifiableObservableListBase<T> implements Deque<T> {

    private final LinkedList<T> list = new LinkedList<>();

    @Override
    public void addFirst(T e) {
        list.addFirst(e);
        beginChange();
        nextAdd(0, 1);
        ++modCount ;
        endChange();
    }

    @Override
    public void addLast(T e) {
        list.addLast(e);
        int size = list.size();
        beginChange();
        nextAdd(size-1, size);
        ++modCount ;
        endChange();
    }

    @Override
    public boolean offerFirst(T e) {
        addFirst(e);
        return true ;
    }

    @Override
    public boolean offerLast(T e) {
        addLast(e);
        return true ;
    }

    @Override
    public T removeFirst() {
        T old = list.removeFirst() ;
        beginChange();
        nextRemove(0, old);
        ++modCount ;
        endChange();
        return old ;
    }

    @Override
    public T removeLast() {
        T old = list.removeLast() ;
        beginChange();
        nextRemove(list.size(), old);
        ++modCount ;
        endChange();
        return old ;
    }

    @Override
    public T pollFirst() {
        T result = list.pollFirst();
        if (result != null) {
            beginChange();
            nextRemove(0, result);
            ++modCount ;
            endChange();
        }
        return result ;
    }

    @Override
    public T pollLast() {
        T result = list.pollLast();
        if (result != null) {
            beginChange();
            nextRemove(list.size(), result);
            ++modCount ;
            endChange();
        }
        return result ;
    }

    @Override
    public T getFirst() {
        return list.getFirst() ;
    }

    @Override
    public T getLast() {
        return list.getLast() ;
    }

    @Override
    public T peekFirst() {
        return list.peekFirst() ;
    }

    @Override
    public T peekLast() {
        return list.peekLast() ;
    }

    @Override
    public boolean removeFirstOccurrence(Object o) {

        // not efficient: maybe a more efficient way, but we need the index...
        int index = list.indexOf(o);
        if (index > -1) {
            remove(index);
            return true ;
        } else {
            return false ;
        }
    }

    @Override
    public boolean removeLastOccurrence(Object o) {

        // not efficient: maybe a more efficient way, but we need the index...
        int index = list.lastIndexOf(o);
        if (index > -1) {
            remove(index);
            return true ;
        } else {
            return false ;
        }
    }

    @Override
    public boolean offer(T e) {
        return offerLast(e);
    }

    @Override
    public T remove() {
        return removeFirst();
    }

    @Override
    public T poll() {
        return pollFirst();
    }

    @Override
    public T element() {
        return getFirst();
    }

    @Override
    public T peek() {
        return peekFirst();
    }

    @Override
    public void push(T e) {
        addFirst(e);
    }

    @Override
    public T pop() {
        return removeFirst();
    }

    @Override
    public Iterator<T> descendingIterator() {
        return list.descendingIterator();
    }

    @Override
    public T get(int index) {
        return list.get(index);
    }

    @Override
    public int size() {
        return list.size();
    }

    @Override
    protected void doAdd(int index, T element) {
        list.add(index, element);
    }

    @Override
    protected T doSet(int index, T element) {
        return list.set(index, element);
    }

    @Override
    protected T doRemove(int index) {
        return list.remove(index);
    }

}

使用示例:

    ObservableLinkedList<String> list = new ObservableLinkedList<>();
    list.addListener((Change<? extends String> c) -> {
        while (c.next()) {
            if (c.wasAdded()) {
                System.out.println("Added from "+c.getFrom()+" to "+c.getTo()+" "+c.getAddedSubList());
            }
            if (c.wasRemoved()) {
                System.out.println("Removed from "+c.getFrom() + " to "+c.getTo()+" "+c.getRemoved());
            }
            if (c.wasUpdated()) {
                System.out.println("Updated");
            }
            if (c.wasPermutated()) {
                System.out.println("Permutated");
            }
        }
    });
    list.addAll("Two", "Three", "Four");
    list.offerFirst("One");
    list.offer("Five");
    System.out.println(list.pollFirst());
    System.out.println(list.pollLast());