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);
}
};
}
总结起来,主要收获就是
- 能用epress?A:B尽量不用if-else..
- 能"懒"就"懒",尽量避免没必要的copy操作
