public abstract class AbstractCollection<E> implements Collection<E> {
/**
* 唯一构造方法
*/
protected AbstractCollection() {
}
// Query Operations
/**
*
* 返回集合中元素的迭代器
*/
public abstract Iterator<E> iterator();
public abstract int size();
public boolean isEmpty() {
return size() == 0; //size=0则此方法返回true
}
public boolean contains(Object o) {
Iterator<E> e = iterator(); //获取此集合的迭代器
if (o==null) {
while (e.hasNext())
if (e.next()==null) //如果此集合允许null元素,找到则返回true
return true;
} else {
while (e.hasNext())
if (o.equals(e.next()))
return true;
}
return false;
}
/**
* 此方法是同步的,即使在遍历集合的过程中发现集合已经改变,任然可以返回
* 正确的结果
*
* 此方法等同于:
*
* List<E> list = new ArrayList<E>(size());
* for (E e : this)
* list.add(e);
* return list.toArray();
*/
public Object[] toArray() {
Object[] r = new Object[size()]; //新建一个对象数组,长度为集合的长度
Iterator<E> it = iterator();
for (int i = 0; i < r.length; i++) { //遍历赋值
if (! it.hasNext()) // 遍历过程中,集合中有元素被移除,长度减少
return Arrays.copyOf(r, i); //则仅返回长度为i的数组,i=当前集合长度
r[i] = it.next();
}
//如果遍历完后发现集合还有更多的元素,即在遍历时有元素被添加进集合,调用
//finishToArray方法添加剩余的元素
return it.hasNext() ? finishToArray(r, it) : r;
}
public <T> T[] toArray(T[] a) {
int size = size(); //当前集合长度
T[] r = a.length >= size ? a : //如果a的长度大于等于size,把a赋给r,否则新建一个元素类型为a元素类型,size长度的数组
(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()) { 遍历过程中,集合中有元素被移除,长度减少.或遍历集合结束
if (a != r) //表明是新建的数组
return Arrays.copyOf(r, i);
r[i] = null; // 表明是a,则多加一个null结束符
return r;
}
r[i] = (T)it.next();
}
return it.hasNext() ? finishToArray(r, it) : r;
}
/**
* 当it还有更多的元素,重新分配数组。并把剩余元素添加进数组
*/
private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
int i = r.length; //原来数组长度存入i中
while (it.hasNext()) {
int cap = r.length;
if (i == cap) { //表明未重新分配数组长度
int newCap = ((cap / 2) + 1) * 3; //新数组长度的计算公式,大约扩充1.5倍
if (newCap <= cap) { // 如果分配后发生了整型溢出
if (cap == Integer.MAX_VALUE)
throw new OutOfMemoryError("Required array size too large");
newCap = Integer.MAX_VALUE;
}
r = Arrays.copyOf(r, newCap); //新建一个长度为newCap的数组,并把r中数据存入
}
r[i++] = (T) it.next(); //添加集合剩余元素到新数组
}
// 修剪多余的长度
return (i == r.length) ? r : Arrays.copyOf(r, i);
}
// Modification Operations
/**
* 调用此方法总是抛出一个异常,需要子类去重写此方法
*/
public boolean add(E e) {
throw new UnsupportedOperationException();
}
/**
* 此方法会首先在集合中查找指定元素o,如果找到就移除它
* 移除的是第一个找到的匹配的值
*/
public boolean remove(Object o) {
Iterator<E> e = iterator();
if (o==null) { //集合支持null元素
while (e.hasNext()) {
if (e.next()==null) {
e.remove();
return true;
}
}
} else {
while (e.hasNext()) {
if (o.equals(e.next())) {
e.remove();
return true;
}
}
}
return false;
}
// Bulk Operations
public boolean containsAll(Collection<?> c) {
Iterator<?> e = c.iterator();
while (e.hasNext())
if (!contains(e.next())) //如果c中有一个元素不在本集合中则返回false
return false;
return true;
}
/**
* 此方法将抛出一个UnsupportedOperationException,除非子类重写了add方法
*/
public boolean addAll(Collection<? extends E> c) {
boolean modified = false;
Iterator<? extends E> e = c.iterator();
while (e.hasNext()) {
if (add(e.next())) //如果有一个元素添加失败就返回false
modified = true;
}
return modified;
}
public boolean removeAll(Collection<?> c) {
boolean modified = false;
Iterator<?> e = iterator();
while (e.hasNext()) {
if (c.contains(e.next())) { //如果c中元素也保含在本集合中则移除它
e.remove();
modified = true;
}
}
return modified;
}
public boolean retainAll(Collection<?> c) {
boolean modified = false;
Iterator<E> e = iterator();
while (e.hasNext()) {
if (!c.contains(e.next())) { //遍历集合元素,如果元素不包含在c中,则移除此元素
e.remove(); //取的是交集
modified = true;
}
}
return modified;
}
public void clear() {
Iterator<E> e = iterator();
while (e.hasNext()) { //依次调用next和remove方法
e.next();
e.remove();
}
}
// String conversion
/**
* 重写toString方法,返回格式:[e.toString, e2.toString, ...]
* */
public String toString() {
Iterator<E> i = iterator();
if (!i.hasNext()) //如果集合为空返回[]
return "[]";
StringBuilder sb = new StringBuilder();
sb.append('[');
for (;;) {
E e = i.next();
sb.append(e == this ? "(this Collection)" : e);
if (!i.hasNext())
return sb.append(']').toString();
sb.append(", ");
}
}
}
/**
* 唯一构造方法
*/
protected AbstractCollection() {
}
// Query Operations
/**
*
* 返回集合中元素的迭代器
*/
public abstract Iterator<E> iterator();
public abstract int size();
public boolean isEmpty() {
return size() == 0; //size=0则此方法返回true
}
public boolean contains(Object o) {
Iterator<E> e = iterator(); //获取此集合的迭代器
if (o==null) {
while (e.hasNext())
if (e.next()==null) //如果此集合允许null元素,找到则返回true
return true;
} else {
while (e.hasNext())
if (o.equals(e.next()))
return true;
}
return false;
}
/**
* 此方法是同步的,即使在遍历集合的过程中发现集合已经改变,任然可以返回
* 正确的结果
*
* 此方法等同于:
*
* List<E> list = new ArrayList<E>(size());
* for (E e : this)
* list.add(e);
* return list.toArray();
*/
public Object[] toArray() {
Object[] r = new Object[size()]; //新建一个对象数组,长度为集合的长度
Iterator<E> it = iterator();
for (int i = 0; i < r.length; i++) { //遍历赋值
if (! it.hasNext()) // 遍历过程中,集合中有元素被移除,长度减少
return Arrays.copyOf(r, i); //则仅返回长度为i的数组,i=当前集合长度
r[i] = it.next();
}
//如果遍历完后发现集合还有更多的元素,即在遍历时有元素被添加进集合,调用
//finishToArray方法添加剩余的元素
return it.hasNext() ? finishToArray(r, it) : r;
}
public <T> T[] toArray(T[] a) {
int size = size(); //当前集合长度
T[] r = a.length >= size ? a : //如果a的长度大于等于size,把a赋给r,否则新建一个元素类型为a元素类型,size长度的数组
(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()) { 遍历过程中,集合中有元素被移除,长度减少.或遍历集合结束
if (a != r) //表明是新建的数组
return Arrays.copyOf(r, i);
r[i] = null; // 表明是a,则多加一个null结束符
return r;
}
r[i] = (T)it.next();
}
return it.hasNext() ? finishToArray(r, it) : r;
}
/**
* 当it还有更多的元素,重新分配数组。并把剩余元素添加进数组
*/
private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
int i = r.length; //原来数组长度存入i中
while (it.hasNext()) {
int cap = r.length;
if (i == cap) { //表明未重新分配数组长度
int newCap = ((cap / 2) + 1) * 3; //新数组长度的计算公式,大约扩充1.5倍
if (newCap <= cap) { // 如果分配后发生了整型溢出
if (cap == Integer.MAX_VALUE)
throw new OutOfMemoryError("Required array size too large");
newCap = Integer.MAX_VALUE;
}
r = Arrays.copyOf(r, newCap); //新建一个长度为newCap的数组,并把r中数据存入
}
r[i++] = (T) it.next(); //添加集合剩余元素到新数组
}
// 修剪多余的长度
return (i == r.length) ? r : Arrays.copyOf(r, i);
}
// Modification Operations
/**
* 调用此方法总是抛出一个异常,需要子类去重写此方法
*/
public boolean add(E e) {
throw new UnsupportedOperationException();
}
/**
* 此方法会首先在集合中查找指定元素o,如果找到就移除它
* 移除的是第一个找到的匹配的值
*/
public boolean remove(Object o) {
Iterator<E> e = iterator();
if (o==null) { //集合支持null元素
while (e.hasNext()) {
if (e.next()==null) {
e.remove();
return true;
}
}
} else {
while (e.hasNext()) {
if (o.equals(e.next())) {
e.remove();
return true;
}
}
}
return false;
}
// Bulk Operations
public boolean containsAll(Collection<?> c) {
Iterator<?> e = c.iterator();
while (e.hasNext())
if (!contains(e.next())) //如果c中有一个元素不在本集合中则返回false
return false;
return true;
}
/**
* 此方法将抛出一个UnsupportedOperationException,除非子类重写了add方法
*/
public boolean addAll(Collection<? extends E> c) {
boolean modified = false;
Iterator<? extends E> e = c.iterator();
while (e.hasNext()) {
if (add(e.next())) //如果有一个元素添加失败就返回false
modified = true;
}
return modified;
}
public boolean removeAll(Collection<?> c) {
boolean modified = false;
Iterator<?> e = iterator();
while (e.hasNext()) {
if (c.contains(e.next())) { //如果c中元素也保含在本集合中则移除它
e.remove();
modified = true;
}
}
return modified;
}
public boolean retainAll(Collection<?> c) {
boolean modified = false;
Iterator<E> e = iterator();
while (e.hasNext()) {
if (!c.contains(e.next())) { //遍历集合元素,如果元素不包含在c中,则移除此元素
e.remove(); //取的是交集
modified = true;
}
}
return modified;
}
public void clear() {
Iterator<E> e = iterator();
while (e.hasNext()) { //依次调用next和remove方法
e.next();
e.remove();
}
}
// String conversion
/**
* 重写toString方法,返回格式:[e.toString, e2.toString, ...]
* */
public String toString() {
Iterator<E> i = iterator();
if (!i.hasNext()) //如果集合为空返回[]
return "[]";
StringBuilder sb = new StringBuilder();
sb.append('[');
for (;;) {
E e = i.next();
sb.append(e == this ? "(this Collection)" : e);
if (!i.hasNext())
return sb.append(']').toString();
sb.append(", ");
}
}
}