Java容器解析系列(2) 具体化的第一步——Collection到AbstractCollection
在通向具体化的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来实现的;
Java容器解析系列(2) 具体化的第一步——Collection到AbstractCollection的更多相关文章
- Java容器解析系列(0) 开篇
最近刚好学习完成数据结构与算法相关内容: Data-Structures-and-Algorithm-Analysis 想结合Java中的容器类加深一下理解,因为之前对Java的容器类理解不是很深刻, ...
- Java容器解析系列(11) HashMap 详解
本篇我们来介绍一个最常用的Map结构--HashMap 关于HashMap,关于其基本原理,网上对其进行讲解的博客非常多,且很多都写的比较好,所以.... 这里直接贴上地址: 关于hash算法: Ha ...
- Java容器解析系列(1) 迭代的进化——从Enumeration到Iterator
在Java中,对于所有的Collection,都有一个特性,可以通过迭代器来遍历和删除其中的元素,因为Collection接口继承自Iterable接口. public interface Colle ...
- Java容器解析系列(13) WeakHashMap详解
关于WeakHashMap其实没有太多可说的,其与HashMap大致相同,区别就在于: 对每个key的引用方式为弱引用; 关于java4种引用方式,参考java Reference 网上很多说 弱引用 ...
- Java容器解析系列(10) Map AbstractMap 详解
前面介绍了List和Queue相关源码,这篇开始,我们先来学习一种java集合中的除Collection外的另一个分支------Map,这一分支的类图结构如下: 这里为什么不先介绍Set相关:因为很 ...
- Java容器解析系列(7) ArrayDeque 详解
ArrayDeque,从名字上就可以看出来,其是通过数组实现的双端队列,我们先来看其源码: /** 有自动扩容机制; 不是线程安全的; 不允许添加null; 作为栈使用时比java.util.Stac ...
- Java容器解析系列(8) Comparable Comparator
Comparable和Comparator接口是两个用于对对象进行大小比较的接口,在java集合相关类中,也被经常地使用到. 关于其使用,可以参考网络上的其他博客(没什么好说的);这里阐述关于这两个接 ...
- Java容器解析系列(9) PrioriyQueue详解
PriorityQueue:优先级队列; 在介绍该类之前,我们需要先了解一种数据结构--堆,在有些书上也直接称之为优先队列: 堆(Heap)是是具有下列性质的完全二叉树:每个结点的值都 >= 其 ...
- Java容器解析系列(6) Queue Deque AbstractQueue 详解
首先我们来看一下Queue接口: /** * @since 1.5 */ public interface Queue<E> extends Collection<E> { / ...
随机推荐
- VSCode 打开文件tab键空格数量异常问题
[1]现象与原因 现象:用Notepad++打开文件,tab键占4个空格键.但是,用VSCode打开,tab键缺变成了3个空格键. 原因:因为VSCode默认启用了根据文件类型自动设置tabsize的 ...
- c语言格式化打印
printf的格式化打印 unsigned int ------------------- %u 打印无符号数 int ----------- ...
- redis工具
pom.xml添加 <!--jedis redis客户端--> <dependency> <groupId>redis.clients</groupId> ...
- Bugku-CTF之域名解析(听说把 flag.baidu.com 解析到123.206.87.240 就能拿到flag)
Day 7 域名解析 50 听说把 flag.baidu.com 解析到123.206.87.240 就能拿到flag
- 通过 UC2000-VG-32G设备呼叫不进号问题排查
1.登陆设备管理页面: 呼叫发起时,呼叫状态显示振铃,但是不进号. 2.查看设备cdr. 3.得出结论:NO CARRIER 由于号码频繁呼叫次数太多运营商对其死锁.
- Oracle错误——user ** lacks CREATE SESSION privilege logon denied
错误 在删除一个用户TEST的情况下,再次新建用户TEST并赋予sysdba权限,使用plsqldev工具登录数据库TEST用户,报错user TEST lacks CREATE SESSION p ...
- 7.24-Codeforces Round #494 (Div. 3)
链接:http://codeforces.com/contest/1003 A. Polycarp's Pockets 题型:模拟 题意:把初始集合拆分,要求相同的数不在同一个集合中,求出需要的集合个 ...
- python之路——模块和包
阅读目录 一 模块 3.1 import 3.2 from ... import... 3.3 把模块当做脚本执行 3.4 模块搜索路径 3.5 编译python文件 二 包 2.2 import 2 ...
- linux基础之find
linux上文件查找工具: locate, find locate: 依赖于事先构建的索引,索引的构建在系统较为空闲时自动进行(周期性任务),手动更新数据库(updatedb) 索引构建过程需要遍历整 ...
- 数组toString()方法,数组常用操作
int[] arr ={1,2,3,4,5}; String arrString = Arrays.toString(arr); //输出[I@7150bd4d System.out.println( ...