Java中集合类源码分析(2)-----Collection和AbstractCollection源码分析

这是该系列文的第二篇,本文介绍了Collection以及它的一个直接实现类AbstractCollection, 这是一个抽象类,其实现了很多方法,也保留了一些抽象方法.Collection 下的大多数子类都继承 自AbstractCollection ，比如 List 的实现类, Set的实现类.下面我们首先来看看Collection.

1.Collection接口

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
impo
4000
rt java.util.Objects;
import java.util.Set;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.function.Predicate;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

public interface Collection<E> extends Iterable<E> {

/**
* 返回集合中元素的数量,如果集合包含了大于Intger.MAX_VALUE个元素,返回Integer.MAX_VALUE
*/
int size();

/**
* 若集合中没有元素,返回true
*/
boolean isEmpty();

/**
*如果这个集合包含指定的元素,返回true
*
*如果指定元素的类型和这个集合的类型不同,抛出ClassCastException异常
*
*如果指定元素为null并且这个集合没有准许null元素.
*/
boolean contains(Object o);

/**
*返回一个拥有这个集合内元素的迭代器.这里并没有对元素的返回顺序进行保证,即对顺序没有保证
*(除非这个集合是某些提供了顺序保证的类的实例)
*/
Iterator<E> iterator();

/**
*返回一个包含这个集合中所有元素的数组.
*如果这集合保证了其在迭代器中迭代的元素顺序的话,这个方法的返回也必须按照相同的顺序
*
*返回的数组将是"安全"的,因为没有由集合维持着的对数组的引用.(换句话说,
*这个方法必须分配一个新的数组给这个集合,哪怕这个集合底层本来就是数组)
*/
Object[] toArray();

/**
*返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。
*例:
*下面的这个x应该是一个只由字符串组成的集合.下述代码被用来把一个集合放入到一个String类型的数组里面
*     String[] y = x.toArray(new String[0]);</pre>
*
* 注意toArray(new Object[0])和toArray()是完全等同的.
*
* @param 这个集合中元素组成数组的类型
* @param 将存储这个集合的元素,确保他是足够大的,否则,一个和和它相同类型的合适大小的数组将被分配来做这件事
* @return 一个包含了这个集合内元素的类型的数组
*         当给定数组的运行时类型(泛型)与集合元素的类型不相同时,抛出 ArrayStoreException
* @throws NullPointerException 当指定的数组为null时
*/
<T> T[] toArray(T[] a);

// Modification Operations

/**
*感觉源码废话有点多..
*就是向集合里面添加一个元素,添加成功了返回true
*有些集合不允许重复,若添加的元素在原集合里面有了,则返回false
*/
boolean add(E e);

/**
*从集合中移除一个元素,如果该指定的元素在集合中是有的,返回true
*
* @throws ClassCastException 当指定的参数类型不能转换为集合声明的类型
* @throws NullPointerException 当指定的元素为null并且集合不允许存在空元素
* @throws UnsupportedOperationException 当remove操作不被该集合支持
*/
boolean remove(Object o);

// Bulk Operations

/**
* 当参数集合c中的所有元素都包含于这个集合时,返回true,否则为false
*/
boolean containsAll(Collection<?> c);

/**
*将指定集合中的所有元素都添加到此集合中,添加成功返回true
*
*/
boolean addAll(Collection<? extends E> c);

/**
* 移除此集合中指定集合的所有元素 ,求指定集合和该集合的差集.
* 做了这样的操作后,这两个集合将没有相同的部分
*/
boolean removeAll(Collection<?> c);

default boolean removeIf(Predicate<? super E> filter) {
Objects.requireNonNull(filter);
boolean removed = false;
final Iterator<E> each = iterator();
while (each.hasNext()) {
if (filter.test(each.next())) {
each.remove();
removed = true;
}
}
return removed;
}

/**
*仅仅保留那些在给定集合与本身集合都有的部分,求交集,换句话说,移除原集合中存在,而指定集合中不存在的元素
*
*/
boolean retainAll(Collection<?> c);

/**
* 清空所有元素,只剩容器
*/
void clear();

// Comparison and hashing

/**
* Compares the specified object with this collection for equality. <p>
*比较给定的集合是否与给定集合相等
*
*这段源码说得挺好,我来翻译翻译
* 当这个集合接口并没有对Object.equals给出条条款款来修改时,程序员直接实现这个接口(换句话说,创造一个类,他是一个Collection,
* 但不是一个Set或者List)必须关系是否选中覆盖这个Object.equals方法.这并不是必须的,最简单的做法就是依赖于Object的做法,
* 但是实现者可能关心的是"值之间的比较"而不是默认的"引用间的比较"(List和Set已经授权了这种值之间的比较,它们比的是值)
*
* 通常Object.equals方法必须是对称的.(比如a.equals(b),那么b.equals(a))List.equals()和Set.equals()
* 的公约声明了List只能和List相等,Set只能和Set相等.因此,一个集合类的常规的equals方法中,List与Set比较,是要返回false
* 的.(由这个逻辑,不可能创建一个即实现Set又实现List的类)
*
*/
boolean equals(Object o);

/**
*返回该集合的hashcode.
* @return the hash code value for this collection
*/
int hashCode();

//8的新特性,先留在这,以后来填坑
@Override
default Spliterator<E> spliterator() {
return Spliterators.spliterator(this, 0);
}

default Stream<E> stream() {
return StreamSupport.stream(spliterator(), false);
}

default Stream<E> parallelStream() {
return StreamSupport.stream(spliterator(), true);
}
}

2.AbstractCollection

package java.util;

import java.util.Arrays;
import java.util.Collection;
import java.util.Objects;

/**
* 这个类提供了一个对于Collection接口具体实现的骨架,缩小了对这个接口实现的要求(事实上后面很多类继承自这个类)
*
* 程序员应该提供一个无参构造..balabala(作者推荐使用的人自己在子类中自己创建一个无参构造)
*
* 文档对这个类里面的每一个非抽象方法都描述了它的详细内容.当集合类的实现方法被实现得更高效时,这些方法是能够被覆盖的
*
* 这个类是Java集合类框架结构的一部分
*/

public abstract class AbstractCollection<E> implements Collection<E> {
/**
* 由子类调用的无参构造方法
*/
protected AbstractCollection() {
}

// 查询操作

/**
* 返回一个这个集合中的元素的迭代器,这是一个抽象方法,子类必须以自己的方式实现这两个方法。
*/
public abstract Iterator<E> iterator();

public abstract int size();

/**
* 返回是该集合是否为空,依靠size完成
*/
public boolean isEmpty() {
return size() == 0;
}

/**
* 判断是否包含某元素,底层是迭代器完成的 它将检查集合中每一个元素是否和给定元素相等(equals方法实现)
*/
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;
}

/**
* 通过这个集合的迭代器,这个方法实现返回一个包含着这个集合中所有元素的数组,以与迭代顺序相同的顺序,将元素连续存入数组,从索引0开始
* 该数组长度等同于集合元素个数即迭代器返回个数,即使在迭代过程中集合发生了改变,可能发生并发改变如果集合允许的话
*
* <p>
* This method is equivalent to:
*
* <pre>
* {
*  @code
*  List<E> list = new ArrayList<E>(size());
*  for (E e : this)
*      list.add(e);
*  return list.toArray();
* }
* </pre>
*/
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;
}

/**
* 下面这个是泛型
*/
@SuppressWarnings("unchecked")
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) {
r[i] = null; // null-terminate
} else if (a.length < i) {
return Arrays.copyOf(r, i);
} else {
System.arraycopy(r, 0, a, 0, i);
if (a.length > i) {
a[i] = null;
}
}
return a;
}
r[i] = (T) it.next();
}
// more elements than expected
return it.hasNext() ? finishToArray(r, it) : r;
}

/**
*分配给数组长度的最大值. 一些虚拟机在数组中保留着一些个头信息.企图分配更大的数组长度可能导致OutOfMemoryError:
*Requested array size exceeds VM limit
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

/**
*这是一个静态私有方法,用在toarray中,如果size的大小小于迭代器迭代的元素。则调用finishToArray来完成之后迭代器的实现。
*当迭代器返回元素个数超出预想时,在转化为数组时重新分配数组,从迭代器中填满后结束.
*
*( 这个方法保存两个int。一个表示当前的迭代的元素的数量，i每次进入循环体就增加一个，而另一个cap表示当前的数组的大小。
*  每次进入循环体，先用cap确认下数组的长度。如果i还没有增长到cap相同的程度则只要将迭代器的下一个元素放入数组并将i加一就行
*  如果i==cap的时候说明需要增大cap。这里增加的cap的一半并加1的大小，然后判断下新的数组的大小是否超过VM的最大界限，如果没有就将继续循环体。
*  在返回的时候使用根据已经迭代的元素i来复制当前数组到一个新的数组中。
*  这里如果判断newCap大小超过了最大的数组大小则调动hugeCapacity调整大小。)
*
* @param r
*           填充着之前元素的数组
* @param it
*           这个集合所进行的迭代器
* @return
*        一个数组,它 包含着之前给定数组中的元素,加上这个迭代器迭代出来的元素,并修整其数组长度
*/
@SuppressWarnings("unchecked
c268
")
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);
}
/*
* 用于确定确定数组极限的值的方法
*
* 如果当前的cap最大值不可在继续增大，即cap+1为负值则抛出一个超出内存大小的异常。
*如果当前的值可以分配，则分配一个MAX_ARRAY_SIZE和MAX_VALUE 中的满足条件的值。
*
*/
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;
}

//修改操作

/**AbstractCollection 的 add(E) 方法默认是抛出异常的，为什么要这样做?为什么不定义为抽象方法?
*
*  如果你想修改一个不可变的集合时，抛出 UnsupportedOperationException 是标准的行为，比如 当你用 Collections.unmodifiableXXX() 方法对某个集合进行处理后，
*  再调用这个集合的 修改方法（add,remove,set…），都会报这个错；
*  因此 AbstractCollection.add(E) 抛出这个错误是准从标准；
*  那为什么会有这个标准呢？
*
*  在 Java 集合总，很多方法都提供了有用的默认行为，比如：
*
*  Iterator.remove()
*  AbstractList.add(int, E)
*  AbstractList.set(int, E)
*  AbstractList.remove(int)
*  AbstractMap.put(K, V)
*  AbstractMap.SimpleImmutableEntry.setValue(V)
*  而之所以没有定义为 抽象方法，是因为可能有很多地方用不到这个方法，用不到还必须实现，这岂不是让人很困惑么。
*
*  个人觉得原因跟和设计模式中的 接口隔离原则 有些相似：
*
*  不要给客户端暴露不需要的方法。     ----引自<< Java 集合深入理解（5）：AbstractCollection>>拭心
*
*/
public boolean add(E e) {
throw new UnsupportedOperationException();
}

/**
*这个方法的实现是重复迭代这个集合来寻找(通过o.equals方法来确定的)指定的元素.如果找到这个元素,调用迭代器的remove方法去删除这个元素
*/
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;
}

// Bulk Operations

/**
*这个方法的实现是通过迭代给定的集合,检查每个迭代器返回的元素是否被包含在源集合中,
*如果全部包含就返回true,底层用的是contains方法
*/
public boolean containsAll(Collection<?> c) {
for (Object e : c)
if (!contains(e))
return false;
return true;
}

/**
* <p>
*这个方法的实现是迭代给定的集合,通过迭代器依次添加每一个元素到集合中,底层用的是add方法
*
* 除非add被覆盖,否则这个方法会报错:UnsupportedOperationException
* (assuming the specified collection is non-empty).
*/
public boolean addAll(Collection<? extends E> c) {
boolean modified = false;
for (E e : c)
if (add(e))
modified = true;
return modified;
}

/**
* 这个方法的实现是通过迭代这个集合,检查每一元素是否被包含在给定的集合中,如果是的话,则调用迭代器的remove将其移除
* 相当于求两集合的差集
*/
public boolean removeAll(Collection<?> c) {
Objects.requireNonNull(c);
boolean modified = false;
Iterator<?> it = iterator();
while (it.hasNext()) {
if (c.contains(it.next())) {
it.remove();
modified = true;
}
}
return modified;
}

/**
*这个实现通过迭代这个集合,检查每一个迭代出来的元素是否被包含在指定的集合中.如果不被包含,那么将被这个集合的迭代器移出
*(底层也是contains方法,contains方法的底层是equals方法实现)
*/
public boolean retainAll(Collection<?> c) {
Objects.requireNonNull(c);
boolean modified = false;
Iterator<E> it = iterator();
while (it.hasNext()) {
if (!c.contains(it.next())) {
it.remove();
modified = true;
}
}
return modified;
}

/**
*这个实现是通过迭代器迭代出集合中的所有元素,用Itreator.remove操作移除每一个迭代出的方法.
*大多数实现为了跟高效的性能,可能会选择覆盖这个方法
*
*同样,如果iterator的remove方法本身为得到实现,也会抛出UnsupportedOperationException
*
*/
public void clear() {
Iterator<E> it = iterator();
while (it.hasNext()) {
it.next();
it.remove();
}
}

// 字符串转换

/**.
* 返回一个该集合的字符串表示.这个字符串表示包含着该集合的元素列表,它的顺序是按照迭代顺序的,同时包含方括号[].
* 相邻的两个元素由", "隔开(逗号和空格)元素被转换为字符串,底层方法为String.valueOf(Object)
*
* @return a string representation of this collection
*/
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(' ');
}
}

}