集合
常用集合类框架图
Iterable接口
Iterable 代表接口具备迭代能力,实现此接口允许对象成为“ for-each循环”语句的目标
public interface Iterable<T> {
// 真正的迭代器
Iterator<T> iterator();
// foreach方法 jdk1.8新增
default void forEach(Consumer<? super T> action) {
Objects.requireNonNull(action);
for (T t : this) {
action.accept(t);
}
}
// 可分割迭代器 专门用于并行迭代 jdk1.8新增
default Spliterator<T> spliterator() {
return Spliterators.spliteratorUnknownSize(iterator(), 0);
}
}
Collection接口
集合只能存放引用类型数据,存的是对象的引用而不是对象本身
类声明
public interface Collection<E> extends Iterable<E>
集合类的共性方法
int size(); // 返回此集合中的元素数
boolean isEmpty(); // 如果此集合不包含元素,则返回 true
boolean contains(Object o); // 如果此集合包含指定的元素,则返回 true
boolean containsAll(Collection<?> c); // 如果此集合包含指定集合中的所有元素,则返回true
Object[] toArray(); // 返回一个包含此集合中所有元素的数组
<T> T[] toArray(T[] a); // 返回包含此集合中所有元素的数组; 如果集合长度大于数组长度,则通过反射新建一个数组并且返回的数组类型与参数数组类型一致。如果小於则直接拷贝,多余位置为null
boolean add(E e); // 向集合中添加元素
boolean addAll(Collection<? extends E> c); // 将指定集合中的所有元素添加到此集合
boolean remove(Object o); // 从该集合中删除指定元素的单个实例
boolean removeAll(Collection<?> c); // 删除指定集合中包含的所有此集合的元素
boolean retainAll(Collection<?> c); // 仅保留此集合中包含在指定集合中的元素
void clear(); // 从此集合中删除所有元素
// 删除满足给定谓词的此集合中的所有元素 jdk1.8新增
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;
}
// 返回以此集合为源的流 jdk1.8新增
default Stream<E> stream() {
return StreamSupport.stream(spliterator(), false);
}
// 返回以此集合为源的并行流 jdk1.8新增
default Stream<E> parallelStream() {
return StreamSupport.stream(spliterator(), true);
}
/* 从 Iterable 重写的方法 **/
Iterator<E> iterator(); // 返回迭代器 hasNext()、next()、remove()
// 在此集合的元素上创建Spliterator jdk1.8新增
default Spliterator<E> spliterator() {
return Spliterators.spliterator(this, 0);
}
AbstractCollection抽象类
实现了 Collection
的部分方法,iterator
和 size
没有实现
类声明
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();
// 经常能见到这个元素为null的分支判断操作
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() {
// 预估的数组大小
Object[] r = new Object[size()];
Iterator<E> it = iterator();
for (int i = 0; i < r.length; i++) {
// 如果i还在循环,但是迭代器却没有下个元素,说明存在并发remove操作,返回数组副本
if (! it.hasNext())
return Arrays.copyOf(r, i);
r[i] = it.next();
}
// 遍历结束,还有下个元素说明有并发add操作,扩容,并将剩余元素添加到数组中,否则直接返回
return it.hasNext() ? finishToArray(r, it) : r;
}
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
// 这里的size只是估计值
int size = size();
// 如果集合长度大于数组长度,则通过反射新建一个数组,如果小于直接拷贝多余位置为null
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++) {
// 如果i还在循环,但是迭代器却没有下个元素,说明存在并发remove操作
if (! it.hasNext()) {
// 如果没有创建新数组,则将最后一位元素置空
if (a == r) {
r[i] = null;
} else if (a.length < i) {
// 如果创建了新数组并且当前数组长度大于a的长度,返回当前数组副本
return Arrays.copyOf(r, i);
} else {
// 如果创建了新数组并且当前数组长度小于等于a的长度,将当前数组拷贝给a
System.arraycopy(r, 0, a, 0, i);
if (a.length > i) {
// 如果a数组长度大于i,则将最后一位置空
a[i] = null;
}
}
return a;
}
r[i] = (T)it.next();
}
// 遍历结束,还有下个元素说明有并发add操作,扩容,并将剩余元素添加到数组中,否则直接返回
return it.hasNext() ? finishToArray(r, it) : r;
}
// 允许分配的最大数组大小,一些 VM 会在数组头部储存头数据,试图尝试创建一个比 Integer.MAX_VALUE - 8 大的数组可能会产生 OOM 异常
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
// 扩容,并且将迭代器剩余的元素添加进数组中
@SuppressWarnings("unchecked")
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;
// 保证数组的最大长度
if (newCap - MAX_ARRAY_SIZE > 0)
newCap = hugeCapacity(cap + 1);
// 扩容
r = Arrays.copyOf(r, newCap);
}
// 向数组添加元素,并且索引自增
r[i++] = (T)it.next();
}
// 如果索引等于数组的长度则直接返回,否则返回实际长度的数组副本
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;
}
// AbstractCollection 不支持 add
public boolean add(E e) {
throw new UnsupportedOperationException();
}
// 通过迭代器从列表删除第一个出现的指定元素
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) {
// 如果传入的数组为空则抛NPE
Objects.requireNonNull(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) {
Objects.requireNonNull(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(' ');
}
}