Question

我需要用List<T>包含一些允许调用set / get但不允许添加/删除调用的类，以便列表保持“固定”长度。我认为我有一个薄的包装类（下面）可以工作，但我不是100％肯定。

我是否错过任何明显的事情？

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

class RestrictedListWrapper<T> implements List<T>
{
    static <T> T fail() throws UnsupportedOperationException
    {
        throw new UnsupportedOperationException();
    }   

    static private class IteratorWrapper<T> implements ListIterator<T>
    {
        final private ListIterator<T> iter;

        private IteratorWrapper(ListIterator<T> iter) { this.iter = iter; }
        static public <T> RestrictedListWrapper.IteratorWrapper<T> wrap(ListIterator<T> target) { 
            return new RestrictedListWrapper.IteratorWrapper<T>(target); 
        }
        @Override public void add(T e) { fail(); }
        @Override public boolean hasNext() { return this.iter.hasNext(); }
        @Override public boolean hasPrevious() { return this.iter.hasPrevious(); }
        @Override public T next() { return this.iter.next(); }
        @Override public int nextIndex() { return this.iter.nextIndex(); }
        @Override public T previous() { return this.iter.previous(); }
        @Override public int previousIndex() { return this.iter.previousIndex(); }
        @Override public void remove() { fail(); }
        @Override public void set(T e) { this.iter.set(e); }
    }       

    final private List<T> list;

    private RestrictedListWrapper(List<T> list) {
        this.list = list;
    }
    static public <T> RestrictedListWrapper<T> wrap(List<T> target) {
        return new RestrictedListWrapper<T>(target);
    }
    @Override public boolean add(T arg0) { return fail();  } 
    @Override public void add(int index, T element) { fail(); }
    @Override public boolean addAll(Collection<? extends T> arg0) {
        return fail(); 
    }
    @Override public boolean addAll(int arg0, Collection<? extends T> arg1) {
        return fail();
    }

    /**
     * clear() allows setting all members of the list to null
     */
    @Override public void clear() {
        ListIterator<T> it = this.list.listIterator();

        while (it.hasNext())
        {
            it.set(null);
            it.next();
        }
    }
    @Override public boolean contains(Object o) {
        return this.list.contains(o);
    }
    @Override public boolean containsAll(Collection<?> c) {
        return this.list.containsAll(c);
    }
    @Override public T get(int index) { return this.list.get(index); }
    @Override public int indexOf(Object o) { return this.list.indexOf(o); }
    @Override public boolean isEmpty() { return false; }
    @Override public Iterator<T> iterator() { 
        return listIterator();
    }
    @Override public int lastIndexOf(Object o) { return this.list.lastIndexOf(o); }
    @Override public ListIterator<T> listIterator() {
        return IteratorWrapper.wrap(this.list.listIterator());
    }
    @Override public ListIterator<T> listIterator(int index) {
        return IteratorWrapper.wrap(this.list.listIterator(index));
    }
    @Override public boolean remove(Object o) { return fail(); }
    @Override public T remove(int index) { fail(); return fail(); }
    @Override public boolean removeAll(Collection<?> c) { return fail(); }
    @Override public boolean retainAll(Collection<?> c) { return fail(); }

    @Override public T set(int index, T element) { return this.list.set(index, element); }
    @Override public int size() { return this.list.size(); }
    @Override public List<T> subList(int fromIndex, int toIndex) {
        return new RestrictedListWrapper<T>(this.list.subList(fromIndex, toIndex));
    }
    @Override public Object[] toArray() { return this.list.toArray(); }
    @Override public <T> T[] toArray(T[] a) { return this.list.toArray(a); }
}

Answer 1

Apache Commons Collections有一个FixedSizedList类，就是这样。

装饰另一个List以修复大小   阻止添加/删除。

添加，删除，清除和保留   操作不受支持。这套   允许的方法（因为它没有   更改列表大小。）

LarvaLabs提供java5-generics-friendly version。

Answer 2

就个人而言，我不愿意重新发明轮子。 Apache Commons有一个ListUtils。 fixedSizeList就是这样做的，毫无疑问谷歌的java类也有。

Answer 3

你错过了：

toString
equals
hashCode

clear打破了LSP。

应该实施java.io.Serializable。

当且仅当目标也是如此时，返回的实现应该实现java.util.RandomAccess。使用静态创建方法而不是裸构造函数的最高分。

目标参数应该在创建时测试null，而不是等待在其上调用方法。

无处不在this。

Answer 4

你真的需要包装任意支持列表吗？或者你只需要一个固定大小的列表？如果是后者，那么JDK就有了它：

List<Foo> foos = Arrays.asList(new Foo[42]);

Answer 5

与skauffman的回答类似，您可以使用Google Collections库ImmutableList<E>，并使用可变E类型。不完全list.set(i,E)，但list.get(i).set(state)可能足够接近。

java：List包装器，其中允许使用get（）/ set（）但不添加/删除

5 个答案: