Collection
Collection是List、Queue和Set的超集,它继承于Iterable,也就是说Collection集合类都支持for-each操作。
方法定义
//返回集合长度,若长度大于Integer.MAX_VALUE,则返回Integer.MAX_VALUE
int size();
//如果集合元素为0,返回true
boolean isEmpty();
//依据equal()方法判断集合中是否包含指定元素
boolean contains(Object o);
//返回一个含有集合中所有元素的数组
Object[] toArray();
//同上,增加了类型转换
<T> T[] toArray(T[] a);
//向集合中加入一个元素,成功返回true,失败或已包含此元素返回false
boolean add(E e)
//删除指定元素
boolean remove(Object o);
//若该集合包含指定集合所有元素,返回true
boolean containsAll(Collection<?> c);
//将指定集合的元素添加到该集合中
boolean addAll(Collection<? extends E> c);
//从集合删除指定集合中的元素
boolean removeAll(Collection<?> c);
//仅仅保留集合中包含在指定集合的元素
boolean retainAll(Collection<?> c);
//清空集合
void clear();
//将此方法抽象,是保证所有子类都覆写此方法,以保证equals的正确行为
boolean equals(Object o);
//同上
int hashCode();
//这个方法在JDK1.8中提供了默认的实现,会使用Iterator的形式删除符合条件的元素
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;
}
AbstractCollection
是Collection接口的一个重要实现类,为抽象类。 如果要实现一个不可修改的集合,需要重写iterator和size
接口,并且返回的Iterator
需要实现hasNext
和next
。而要实现一个可以修改的集合,还必须重写add
方法(默认会抛出异常),返回的Iterator
还需要实现remove
方法。
方法定义
public abstract Iterator<E> iterator();
public abstract int size();
public boolean isEmpty() {return size() == 0;}
//这个方法因为Iterator的存在,可以进行一致性封装,这里需要注意的是对象的比较是通过equals方法,因为调用到了it.next()
//与it.hasNext(),这也是为什么文档注释会写实现集合类需要重写Iterator的这两个方法。
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;
}
//同上,删除也用到了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;
}
//其余方法也要用到Iterator特性,如containsAll(Collaction<?> c)、allAll(Collection<? extends E> c)、
//clear()等
//这个实现相对复杂一些,可以看到扩容最主要的手段是Arrays.copyOf()方法,
//也就是需要将原数组通过复制到新的数组中来实现的。
//在这里实现是为了方便不同具体实现类互相转换,我们在后续会多次见到此方法
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); //仅返回赋完值的部分
r[i] = it.next();
}
//元素比从size()中获取的更多,就需要进一步调整数组大小
return it.hasNext() ? finishToArray(r, it) : r;
}
private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
//记录当前大小
int i = r.length;
while (it.hasNext()) {
int cap = r.length;
//r的长度不够,继续分配
if (i == cap) {
//扩充方式为cap+cap/2+1,也就是1.5倍扩容
int newCap = cap + (cap >> 1) + 1;
// 超过了最大容量,MAX_ARRAY_SIZE=Integer.MAX_VALUE-8
if (newCap - MAX_ARRAY_SIZE > 0)
//重新设置cap的值
newCap = hugeCapacity(cap + 1);
//对r进行扩容
r = Arrays.copyOf(r, newCap);
}
//赋值,进入下一轮循环
r[i++] = (T)it.next();
}
// 由于之前扩容是1.5倍进行的,最后再将其设置到和r实际需要的相同
return (i == r.length) ? r : Arrays.copyOf(r, i);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // 超过了最大正整数,也就是负数
throw new OutOfMemoryError
("Required array size too large");
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
//toString通过StringBuilder拼接每个元素的roString完成。
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(' ');
}
}
来源:oschina
链接:https://my.oschina.net/u/3991724/blog/3207737