一、List接口
有序集合(也称为序列)。该界面的用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引(列表中的位置)访问元素,并搜索列表中的元素。
与集合不同,列表通常允许重复的元素(包括空元素)。列表界面除了Collection中指定的附加条款之外,还添加了迭代器,add,remove,equals和hashCode方法。
public interface List<E> extends Collection<E> {
int size();
boolean isEmpty();
boolean contains(Object o);
Iterator<E> iterator();
Object[] toArray();
<T> T[] toArray(T[] a);
boolean add(E e);
boolean remove(Object o);
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c);
boolean addAll(int index, Collection<? extends E> c);
boolean removeAll(Collection<?> c);
boolean retainAll(Collection<?> c);
void clear();
boolean equals(Object o);
int hashCode();
E get(int index);
E set(int index, E element);
void add(int index, E element);
E remove(int index);
int indexOf(Object o);
int lastIndexOf(Object o);
ListIterator<E> listIterator();
ListIterator<E> listIterator(int index);
List<E> subList(int fromIndex, int toIndex);
//JDK1.8新增内容
/*将该列表的每个元素替换为将该运算符应用于该元素的结果。运营商抛出的错误或运行时异常被转发给呼叫者。*/
default void replaceAll(UnaryOperator<E> operator) {
Objects.requireNonNull(operator);
final ListIterator<E> li = this.listIterator();
while (li.hasNext()) {
li.set(operator.apply(li.next()));
}
}
/*根据指定的比较器引起的顺序排列此列表。此列表中的所有元素必须使用指定的比较器相互比较
如果指定的比较器为null,则该列表中的所有元素都必须实现Comparable接口,并且应该使用元素的自然排序。*/
default void sort(Comparator<? super E> c) {
Object[] a = this.toArray();
Arrays.sort(a, (Comparator) c);
ListIterator<E> i = this.listIterator();
for (Object e : a) {
i.next();
i.set((E) e);
}
}
//用于并行遍历
default Spliterator<E> spliterator() {
return Spliterators.spliterator(this, Spliterator.ORDERED);
}
}
二、AbstractList抽象类
该类提供了List接口的骨架实现。如果要修改的列表,必须另外覆盖set(int,E)方法(否则会抛出UnsupportedOperationException)。如果改变列表的大小,则必须另外覆盖add(int,E)和remove(int)方法。与其他抽象集合实现不同,程序员不必提供迭代器实现;迭代器和列表迭代器由这个类实现,在“随机访问”方法之上:get(int),set(int,E),add(int,E)和remove(int)。
2.1 实现的方法
protected AbstractList() { } //重写AbstractCollection中的add方法,向List集合中添加元素 // java接口和父类中有相同的方法,如果子类不想重写,那么可以不重写,那么实现接口的方法,就相当于父类的方法继承下来。 public boolean add(E e) { add(size(), e); return true; } abstract public E get(int index); public E set(int index, E element) { throw new UnsupportedOperationException(); } public void add(int index, E element) { throw new UnsupportedOperationException(); } public E remove(int index) { throw new UnsupportedOperationException(); } public int indexOf(Object o) { ListIterator<E> it = listIterator(); if (o==null) { while (it.hasNext()) if (it.next()==null) return it.previousIndex(); } else { while (it.hasNext()) if (o.equals(it.next())) return it.previousIndex(); } return -1; } public int lastIndexOf(Object o) { ListIterator<E> it = listIterator(size());//将迭代器置于最后,往后进行迭代 if (o==null) { while (it.hasPrevious()) if (it.previous()==null) return it.nextIndex(); } else { while (it.hasPrevious()) if (o.equals(it.previous())) return it.nextIndex(); } return -1; } public void clear() { removeRange(0, size()); } /*将指定集合中的所有元素插入到此列表中的指定位置(可选操作)。 将当前处于该位置的元素(如果有的话)和随后的任何元素移动到右边(增加其索引)。*/ public boolean addAll(int index, Collection<? extends E> c) { rangeCheckForAdd(index); boolean modified = false; for (E e : c) { add(index++, e); modified = true; } return modified; } //将指定的对象与此列表进行比较以获得相等性。 如果且仅当指定的对象也是列表时,则返回true,两个列表的大小相同,并且两个列表中所有相应的元素对都相等。 public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof List)) return false; ListIterator<E> e1 = listIterator(); ListIterator<?> e2 = ((List<?>) o).listIterator(); while (e1.hasNext() && e2.hasNext()) { E o1 = e1.next(); Object o2 = e2.next(); if (!(o1==null ? o2==null : o1.equals(o2))) return false; } return !(e1.hasNext() || e2.hasNext()); } //返回此列表的哈希码值。 public int hashCode() { int hashCode = 1; for (E e : this) hashCode = 31*hashCode + (e==null ? 0 : e.hashCode()); return hashCode; } //从该列表中删除所有索引在fromIndex(包括)和toIndex之间的独占元素。 protected void removeRange(int fromIndex, int toIndex) { ListIterator<E> it = listIterator(fromIndex); for (int i=0, n=toIndex-fromIndex; i<n; i++) { it.next(); it.remove(); } } protected transient int modCount = 0; private void rangeCheckForAdd(int index) { if (index < 0 || index > size()) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); } private String outOfBoundsMsg(int index) { return "Index: "+index+", Size: "+size(); }
//返回此列表中指定的fromIndex(包括)和toIndex之间的独占视图。 public List<E> subList(int fromIndex, int toIndex) { return (this instanceof RandomAccess ? new RandomAccessSubList<>(this, fromIndex, toIndex) : new SubList<>(this, fromIndex, toIndex)); }public Iterator<E> iterator() { return new Itr(); } public ListIterator<E> listIterator() { return listIterator(0); } public ListIterator<E> listIterator(final int index) { rangeCheckForAdd(index); return new ListItr(index); }
2.2 迭代器
AbstractList
的迭代器其实定义了两个迭代器,一个是实现了
Iterator
接口的迭代器
Itr
,另一个是实现了
ListIterator
并且继承自
Itr
的迭代器
ListItr
。
2.2.1 Irt迭代器
Itr实现了Iterator接口,主要功能是判断当前迭代器的位置(next())、进行删除操作(remove())、防止多迭代器或者多线程操作时的影响(checkForComodification())。
private class Itr implements Iterator<E> {
int cursor = 0;
int lastRet = -1;
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size();
}
public E next() {
checkForComodification();
try {
int i = cursor;
E next = get(i);
//由最近的呼叫返回到下一个或上一个的元素的索引。
lastRet = i;
cursor = i + 1;
return next;
} catch (IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
AbstractList.this.remove(lastRet);
if (lastRet < cursor)
cursor--;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
能用图说明问题,就不扯白话:
next()过程:
remove()过程:
2.2.2 ListItr迭代器
ListItr
实现了
ListIterator
接口,主要是实现
List
反向遍历的特性。,并且重写了
ListIterator
接口中的
set(E e)
、
add(E e)
方法。
private class ListItr extends Itr implements ListIterator<E> {
ListItr(int index) {
cursor = index;
}
public boolean hasPrevious() {
return cursor != 0;
}
public E previous() {
checkForComodification();
try {
int i = cursor - 1;
E previous = get(i);
lastRet = cursor = i;
return previous;
} catch (IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
public int nextIndex() {
return cursor;
}
public int previousIndex() {
return cursor-1;
}
public void set(E e) {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
AbstractList.this.set(lastRet, e);
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
public void add(E e) {
checkForComodification();
try {
int i = cursor;
AbstractList.this.add(i, e);
lastRet = -1;
cursor = i + 1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
}
previous()过程:
add()过程: