上篇文章介绍了一下相关的集合接口,本片文章主要介绍一下List的子类,在这里不能每一个类都涉及到,选择一些常见和具有代表性的来看一下。
本片主要是讲list相关实现的类,从api上可以搜索一下相关子类:
从上面可以看出,这个类是实现List 接口的直接子类,查看源码来了解这个类是如何设计的? 为什么如此设计?
查看api,可以到这个类的简介:
abstractlist是List接口的抽象实现,是一个支持随机存取存储备份优化。此实现不支持添加或替换。子类必须实现抽象方法get()和size()
private class SimpleListIterator implements Iterator<E> {
int pos = -1;
int expectedModCount;
int lastPosition = -1;
SimpleListIterator() {
LinkedList<String> lll;
ArrayList ar;
expectedModCount = modCount;
}
public boolean hasNext() {
return pos + 1 < size();
}
public E next() {
if (expectedModCount == modCount) {
try {
E result = get(pos + 1);
lastPosition = ++pos;
return result;
} catch (IndexOutOfBoundsException e) {
throw new NoSuchElementException();
}
}
throw new ConcurrentModificationException();
}
public void remove() {
if (this.lastPosition == -1) {
throw new IllegalStateException();
}
if (expectedModCount != modCount) {
throw new ConcurrentModificationException();
}
try {
AbstractList.this.remove(lastPosition);
} catch (IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
expectedModCount = modCount;
if (pos == lastPosition) {
pos--;
}
lastPosition = -1;
}
}
这个类实现了Iterator 接口
private final class FullListIterator extends SimpleListIterator implements ListIterator<E> {
FullListIterator(int start) {
if (start >= 0 && start <= size()) {
pos = start - 1;
} else {
throw new IndexOutOfBoundsException();
}
}
public void add(E object) {
if (expectedModCount == modCount) {
try {
AbstractList.this.add(pos + 1, object);
} catch (IndexOutOfBoundsException e) {
throw new NoSuchElementException();
}
pos++;
lastPosition = -1;
if (modCount != expectedModCount) {
expectedModCount = modCount;
}
} else {
throw new ConcurrentModificationException();
}
}
public boolean hasPrevious() {
return pos >= 0;
}
public int nextIndex() {
return pos + 1;
}
public E previous() {
if (expectedModCount == modCount) {
try {
E result = get(pos);
lastPosition = pos;
pos--;
return result;
} catch (IndexOutOfBoundsException e) {
throw new NoSuchElementException();
}
}
throw new ConcurrentModificationException();
}
public int previousIndex() {
return pos;
}
public void set(E object) {
if (expectedModCount == modCount) {
try {
AbstractList.this.set(lastPosition, object);
} catch (IndexOutOfBoundsException e) {
throw new IllegalStateException();
}
} else {
throw new ConcurrentModificationException();
}
}
}
实现了ListIterator 接口,上面这个类,分别是为了实现List接口里面的方法, public Iterator<E> iterator() 和 public ListIterator<E> listIterator() 这俩个方法
public void add(int location, E object) {
throw new UnsupportedOperationException();
}
因为数据存储方式不同,所以添加数据需要在子类中实现
@Override
public boolean add(E object) {
add(size(), object);
return true;
}
这个方法不用解释也能看明白吧,就不复习入门知识了。
public boolean addAll(int location, Collection<? extends E> collection) {
Iterator<? extends E> it = collection.iterator();
while (it.hasNext()) {
add(location++, it.next());
}
return !collection.isEmpty();
}
使用iterator遍历方法,添加数据
@Override
public void clear() {
removeRange(0, size());
}
清理此集合,具体实现查看removeRange
protected void removeRange(int start, int end) {
Iterator<?> it = listIterator(start);
for (int i = start; i < end; i++) {
it.next();
it.remove();
}
}
一看就明白,使用listIterator遍历,利用next 和 remove,上面已经实现了ListIterator 接口的类 FullListIterator
@Override
public boolean equals(Object object) {
if (this == object) {
return true;
}
if (object instanceof List) {
List<?> list = (List<?>) object;
if (list.size() != size()) {
return false;
}
Iterator<?> it1 = iterator(), it2 = list.iterator();
while (it1.hasNext()) {
Object e1 = it1.next(), e2 = it2.next();
if (!(e1 == null ? e2 == null : e1.equals(e2))) {
return false;
}
}
return true;
}
return false;
}
没有什么好解释的,还是利用遍历
public abstract E get(int location);
由于不同的存储方式,需要在子类中具体实现
public int hashCode() {
int result = 1;
Iterator<?> it = iterator();
while (it.hasNext()) {
Object object = it.next();
result = (31 * result) + (object == null ? 0 : object.hashCode());
}
return result;
}
略过。。。。
剩余的方法也不一一列出来了,只是为了明白这个类是如何设计的,可以很清晰的看到: 大部分方法都是根据迭代遍历来进行操作的,也有部分方法由于存储方式的不同,所以需要在具体的子类中实现