Lists工具类--惰性操作的代表

AbstractList<T>是一个不错的抽象类,实现惰性操作全靠它了.

Lists类的主要方法

List<List<T>> partition(List<T> list, int size)

该方法首先区分传入的List是否实现了RandomAccess接口,相当于判断是底层实现ArrayList还是LinkedList,不过具体操作都依赖一个内部类

Partition<T> extends AbstractList<T>

实现了父类的get() 并重写了subList(),size()方法,在遍历时利用了其iterator迭代器方法,如hasNext(),next()等.
这样的实现可以做到,使partition()返回的List只有在真正被遍历时才会进行分割操作,subList(start,end).相当于利用遍历时计算start,offset的时间替代了需要重复的内存.
这是遍历时的计算,可以看到,并没有进行拷贝:

        public List<T> get(int index) {
            Preconditions.checkElementIndex(index, this.size());
            int start = index * this.size;
            int end = Math.min(start + this.size, this.list.size());
            return this.list.subList(start, end);
        }

下面看reverse方法的主题部分:

        return (List)(list instanceof ImmutableList?((ImmutableList)list).reverse()
:(list instanceof Lists.ReverseList?((Lists.ReverseList)list).getForwardList()
:(list instanceof RandomAccess?new Lists.RandomAccessReverseList(list)
:new Lists.ReverseList(list))));

google的Java工程时应该是特别讨厌if--else if--else模式,所以特别喜欢用

express?A:B

不过看起来似乎特别的顺眼,值得学习.
回到正题,只有当传入List为不可变的ImmutableList时,才真正进行了翻转copy操作,即List.reverse().
正如partition方法一样,普通的List也只是返回一个继承了AbstractList的可遍历类.主要方法:

        public T get(int index) {
            return this.forwardList.get(this.reverseIndex(index));
        }
        private int reverseIndex(int index) {
            int size = this.size();
            Preconditions.checkElementIndex(index, size);
            return size - 1 - index;
        }        

List<F> transform(List<T> , Function<T,F >)方法稍有不同

该方法返回的类继承了抽象类AbstractSequentialList<T>,它的抽象方法IlistIterator,其中完成转换还用到了另一个抽象类,核心依然是Function的F apply(T)方法:

public ListIterator<T> listIterator(int index) {
       return new TransformedListIterator(this.fromList.listIterator(index)) {
            T transform(F from) {
                return TransformingSequentialList.this.function.apply(from);
            }
        };
}

总结起来,主要收获就是

1. 能用epress?A:B尽量不用if-else..
2. 能"懒"就"懒",尽量避免没必要的copy操作