Question

在Java中拥有一个具有List的所有功能但具有最大存储容量的数据结构对我来说很有用，并且在添加新数据时会删除旧数据。可以想象，在某些时候，我可能想要实现一个固定大小的队列，它保持数据的更一般顺序，并将旧数据丢弃在该顺序中最低，但这是未来的。

目前我正在实施它：

public class FixedSizeList<T> {

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

  public FixedSizeQueue(int maxSize) {
    this.maxSize = maxSize < 0 ? 0 : maxSize;
  }

  public T add(T t) {
    list.add(t);
    return list.size() > maxSize ? list.remove() : null;
  }

  // add remaining methods...

}

是否存在（a）满足我需求的现有数据结构，或者（b）实现此数据结构的更好方法？

Answer 1

我会使用数组和2个索引作为列表的头部和尾部。确保头部总是＆lt;尾巴，你很安全。

Answer 2

除非您想使用实际数组，否则我不相信您可以使用列表类型数据结构。

我个人会扩展一个现有的列表类来获取功能，并覆盖add方法。这样您就可以免费获得所有其他列表操作。即以下内容......

public class FixedSizeArrayList<T> extends ArrayList<T> {
    private final int maxSize;
    public FixedSizeArrayList(int maxSize) {
        super();
        this.maxSize = maxSize
    }

    public boolean add(T t) {
        if (size() >= maxSize) {
            remove(0);
        }
        return super.add(t);
    }

    // implementation of remaining add methods....
}

Answer 3

以下是基于Guava的ForwardingList的大小限制的列表：

转发其所有方法的列表调用另一个列表。子类应该覆盖一个或多个方法修改后备的行为根据装饰者的需要列出图案。

Guava为所有JDK-5 Collection类型都有这样的基类。它们中的每一个都实现了相同的目的：在将所有默认功能委派给底层集合的同时，轻松增加价值。

public class LimitingList<E> extends ForwardingList<E> {

    private final class LimitingListIterator extends ForwardingListIterator<E> {

        private final ListIterator<E> innerListIterator;

        private LimitingListIterator(final ListIterator<E> innerListIterator) {
            this.innerListIterator = innerListIterator;
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public void add(final E element) {
            if (inner.size() < maxSize)
                innerListIterator.add(element);
            else
                throw new IndexOutOfBoundsException();
        }

        @Override
        protected ListIterator<E> delegate() {
            return innerListIterator;
        }
    }

    public LimitingList(final int maxSize) {
        this(new ArrayList<E>(), maxSize);
    }

    public LimitingList(final List<E> inner, final int maxSize) {
        super();
        this.inner = inner;
        this.maxSize = maxSize;
    }

    @Override
    public boolean addAll(final Collection<? extends E> collection) {
        boolean changed = false;
        for (final E item : collection) {
            final boolean tmpChanged = add(item);
            changed = changed || tmpChanged;
            if (!tmpChanged)
                break;
        }
        return changed;
    }

    @Override
    public boolean add(final E e) {
        if (inner.size() < maxSize)
            return super.add(e);
        else
            return false;
    }

    @Override
    public ListIterator<E> listIterator() {
        return new LimitingListIterator(inner.listIterator());
    }

    @Override
    public void add(final int index, final E element) {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean addAll(final int index, final Collection<? extends E> elements) {
        throw new UnsupportedOperationException();
    }

    @Override
    public ListIterator<E> listIterator(final int index) {
        return new LimitingListIterator(inner.listIterator(index));
    }

    private final int maxSize;
    private final List<E> inner;

    @Override
    protected List<E> delegate() {
        return inner;
    }

}

它将所有实际功能委托给基础列表，默认情况下是一个ArrayList（单个参数构造函数），但您也可以提供（两个参数构造函数）

Answer 4

如果扩展LinkedList类，您将可以直接访问其所有方法。而不必写像

这样的东西

fixedList.getList().pop()

你可以写

fixedList.pop()

然后，您可以覆盖需要添加maxSize条件的方法。

Java中的最大大小列表

4 个答案: