在通向具体化的List,Queue之前,我们需要先了解一下Collection接口和AbstractCollection抽象类,这两个都是处于Collection顶层的存在.
Collection接口，是Collection hierarchy的根接口，我们来看其定义了哪些必须实现的方法：
/**
Collection接口，是CollectionC hierarchy的根接口。
一个Collection表示一些元素对象的聚集;
一些Collection的实现类允许重复的元素对象，另一些不允许；
一些有序而另一些没有；
有些不允许元素为null,试图向其中添加null元素是会抛出非检查时异常;
Collection实现类是否是同步的取决于其具具体实现;
Collection并不提供直接的Collection的具体实现类，而是通过一些子接口，如Set和List等。这些接口被用来提供关于聚集操作的更为具体的泛化。
程序员应当为每一个Collection实现类提供一个无参的构造方法和一个参数为Collection的构造方法;
* @since 1.2
*/
public interface Collection<E> extends Iterable<E> {
int size();
boolean isEmpty();
boolean contains(Object o);
Iterator<E> iterator();
// 以数组的形式返回Collection中所有对象,如果Collection实现类是有序的,返回的该数组也应该同样的有序;
// 返回的数组必须保证当前Collection对象对该数组没有任何引用,也就是说,应该分配一个新的数组,并把元素填充到该数组中,并返回;
// 因为是一个新的数组,也就保证了返回的数组是可以被随意修改的,而不会影响到Collection对象(这里其实仅保证修改返回的数组中元素的顺序时不会影响到Collection对象,如果修改数组中某个位置的对象的内容,则Collection中相应的对象内容也会被修改,因为其实是同一个对象,这里的复制为浅复制)
Object[] toArray();
// 如果传入的数组大小能够容纳Collection中的所有元素,将Collection中的所有元素填入传入的数组中,如果有多余空间,其余的空间都会被置为null;
// 如果传入的数组空间不够,该方法同toArray()方法;
// 如果传入的数组元素类型不是集合中元素类型的父类型,抛出ArrayStoreException
// 如果传入的数组为null,抛出NullPointerException
<T> T[] toArray(T[] a);
boolean add(E e);
boolean remove(Object o);
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c);
boolean removeAll(Collection<?> c);
// 保留只在当前Collection中存在而在指定Collection中不存在的对象
boolean retainAll(Collection<?> c);
void clear();
boolean equals(Object o);
// Collection对hashCode()方法没有特别的规定,但是程序员需要注意,当实现equals()方法时,
// 应该实现hashCode()方法,因为c1.equals(c2)暗示(imply)了c1.hashCode()==c2.hashCode()
int hashCode();
}
从上面的代码可以看出:
Collection规定了其实现类必须具有增删改查的能力(其中"删"为可选操作);
其所定义的所有方法都直接或间接为这些功能实现提供服务;
补充:
- Collection规定了实现类判断两个元素相等的方式为 (onull ? enull : o.equals(e))
- Collection中的有些方法不一定每个实现类都要实现,包括remove(),removeAll(),add(),addAll(),clear(),retailAll(),这些方法称为可选操作(optional operation),且都与删除元素有关;如果实现类决定不实现该方法时,应默认抛出UnsupportedOperationException;
为什么要有可选操作:
防止在设计中出现接口爆炸的情况,避免为了各种特例单独定义接口
也就是说,如果没有这些可选操作,那么为了限制一些类不支持这些操作,我们需要再定义一个接口,这种情况下假设叫"NoOpionalCollection";
在Java集合中,有很多地方有可选操作这种需求(比如要有一个集合类不允许添加元素,一个集合类不允许修改元素,一个集合类不允许删除元素),如果为这些特殊需求每个都设计一个接口,那么就有,UnModifiableCollection,UnAddCollection等,这是完全没有必要的;而如果有这些可选操作,如果不支持这个操作,直接抛出异常即可;
接下来我们将目光再往下看,AbstractCollection在Collection的基础上添加了哪些具体实现:
/**
* @since 1.2
*/
public abstract class AbstractCollection<E> implements Collection<E> {
protected AbstractCollection() {}
public abstract Iterator<E> iterator();
public abstract int size();
public boolean isEmpty() {
return size() == 0;
}
// 默认通过迭代器来查找是否存在一个指定元素,子类如果有更高效的实现方式,可以考虑重写该方法
public boolean contains(Object o) {
Iterator<E> it = iterator();
if (o==null) {
while (it.hasNext())
if (it.next()==null)
return true;
} else {
while (it.hasNext())
if (o.equals(it.next()))
return true;
}
return false;
}
public Object[] toArray() {
// Estimate size of array; be prepared to see more or fewer elements
Object[] r = new Object[size()];
Iterator<E> it = iterator();
for (int i = 0; i < r.length; i++) {
if (! it.hasNext()) // fewer elements than expected
return Arrays.copyOf(r, i);
r[i] = it.next();
}
return it.hasNext() ? finishToArray(r, it) : r;
}
public <T> T[] toArray(T[] a) {
// Estimate size of array; be prepared to see more or fewer elements
int size = size();
T[] r = a.length >= size ? a :
(T[])java.lang.reflect.Array
.newInstance(a.getClass().getComponentType(), size);
Iterator<E> it = iterator();
for (int i = 0; i < r.length; i++) {
if (! it.hasNext()) { // fewer elements than expected
if (a != r)
return Arrays.copyOf(r, i);
r[i] = null; // null-terminate
return r;
}
r[i] = (T)it.next();
}
return it.hasNext() ? finishToArray(r, it) : r;
}
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
int i = r.length;
while (it.hasNext()) {
int cap = r.length;
if (i == cap) {
int newCap = cap + (cap >> 1) + 1;
// overflow-conscious code
if (newCap - MAX_ARRAY_SIZE > 0)
newCap = hugeCapacity(cap + 1);
r = Arrays.copyOf(r, newCap);
}
r[i++] = (T)it.next();
}
// trim if overallocated
return (i == r.length) ? r : Arrays.copyOf(r, i);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError
("Required array size too large");
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
// Modification Operations
public boolean add(E e) {
throw new UnsupportedOperationException();
}
// 默认通过Iterator来检索,删除指定元素
public boolean remove(Object o) {
Iterator<E> it = iterator();
if (o==null) {
while (it.hasNext()) {
if (it.next()==null) {
it.remove();
return true;
}
}
} else {
while (it.hasNext()) {
if (o.equals(it.next())) {
it.remove();
return true;
}
}
}
return false;
}
public boolean containsAll(Collection<?> c) {
for (Object e : c)
if (!contains(e))
return false;
return true;
}
public boolean addAll(Collection<? extends E> c) {
boolean modified = false;
for (E e : c)
if (add(e))
modified = true;
return modified;
}
public boolean removeAll(Collection<?> c) {
boolean modified = false;
Iterator<?> it = iterator();
while (it.hasNext()) {
if (c.contains(it.next())) {
it.remove();
modified = true;
}
}
return modified;
}
public boolean retainAll(Collection<?> c) {
boolean modified = false;
Iterator<E> it = iterator();
while (it.hasNext()) {
if (!c.contains(it.next())) {
it.remove();
modified = true;
}
}
return modified;
}
public void clear() {
Iterator<E> it = iterator();
while (it.hasNext()) {
it.next();
it.remove();
}
}
public String toString() {
Iterator<E> it = iterator();
if (! it.hasNext())
return "[]";
StringBuilder sb = new StringBuilder();
sb.append('[');
for (;;) {
E e = it.next();
sb.append(e == this ? "(this Collection)" : e);
if (! it.hasNext())
return sb.append(']').toString();
sb.append(',').append(' ');
}
}
}
可以看出,AbstractCollection提供了一个Collection集合实现及基本骨架,为进一步实现,指明了方向:
- 实现一个不可变的Collection,只需要继承该类并实现iterator()和size(),并且对iterator()返回的Iterator实现hasNext()和next();
- 实现可变的Collection,还需要实现add()方法,并对iterator()方法返回的Iterator实现remove()方法;
- AbstractCollection中几乎所有默认的操作,都是通过Iterator来实现的;