java集合——集合接口+迭代器接口

【0】README

0.1） 本文描述转自 core java volume 1，源代码 diy 的，旨在理解 java集合框架——集合接口+迭代器接口 的相关知识；
0.2） for full source code , please visit https://github.com/pacosonTang/core-java-volume/tree/master/chapter13

【1】将集合的接口与实现分离

1.1）java集合类库将接口与实现分离。我们看一下，队列是如何分离的；
1.2）队列接口指出可以再队列的尾部添加元素，在队列的头部删除元素，并可以查找队列中元素的个数；

1.2.1）一个队列接口的最小形式类似下面这样：

interface Queue<E>
{void add(E element);E remove();int size;
}

1.2.2）队列通常有两种实现方式： 一种是使用循环数组，另一种是使用链表；
1.2.3）每一个实现都可以通过一个实现了 Queue接口的类表示：

class CircularArrayQueue<E> implements Queue<E> // not an actual library class
{CircularArrayQueue(int capacity) {...}pubilc void add(E element) {...}public E remove() {...}public int size(){...}private E[] elements;private int head;private int tail;
}
class LinkedListQueue<E> implements Queue<E> // not an actual library class
{LinkedListQueue() {}pubilc void add(E element) {...}public E remove() {...}public int size(){...}private Link head;private Link tail;
}

Annotation）

A1）如果需要使用循环数组队列： 可以使用 ArrayDeque 类；
A2）如果需要使用一个链表队列： 就直接使用 LinkedList 类，这个类实现了 Queue接口；

1.3）使用接口类型存放集合的引用：

Queue<Customer> expressLane = new CircularArrayQueue<>(100);
expressLane.add(new Customer("Harry"));

1.3.1）只需要对程序的一个地方做出修改，即调用构造器的地方，如果觉得LinkedListQueue是个更好的选择，将代码修改为：

Queue<Customer> expressLane = new LinkedListQueue<>(100);
expressLane.add(new Customer("Harry")); // nothing changed

1.3.2）因为循环数组要比链表效率高，因此多数人优先选择循环数组；循环数组是一个有界集合，即容量有限。如果程序中要收集的对象数量没有上限，就最好使用链表来实现；
1.3.3）在研究API文档时，发现另外一组名字为 Abstract开头的类： 如， AbstractQueue，这些类是为类库实现者而设计的，如果想要实现自己的队列类，会发现扩展AbstractQueue类要比实现Queue接口中的所有方法要轻松得多；

【2】java类库中的集合接口和迭代器接口

2.1）在java类库中，集合类的基本接口是 Collection 接口，有两个基本方法：

public interface Collection<E>
{boolean add(E element); Iterator<E> iterator();
}

对上述代码的分析（Analysis）：

A1）add方法： 用于向集合添加元素，如果添加元素确实改变了集合就返回ture，否则返回false；如，如果试图向集合中添加一个对象，而这个对象在集合中已经存在，这个添加请求就没有实效了，因为集合中不允许有重复的对象；
A2）iterator方法：该方法用于返回一个实现了 Iterator接口的对象。可以使用这个迭代器对象依次访问集合中的元素：

2.2）迭代器， Iterator接口包含3个方法：

public interface Iterator<E>
{E next();boolean hasNext();void remove();
}

2.2.1）通过反复调用 next方法，可以逐个访问集合中的每个元素。但是，如果达到了集合的末尾，next方法将抛出一个 NoSuchElementException；因此，需要在 next之前调用 hasNext方法；
2.2.2）看个荔枝：

Collection<String> c = ...; //集合
Iterator<String> iter = c.iterator(); //集合迭代器
while(iter.hasNext()) //判断集合中是否还有下一元素
{String element = iter.next();do sth with element
}

Attention）从Java SE 5.0 后，可以使用for each循环表示上述操作：

for(String elements : c)
{do sth with element
}

对上述代码的分析（Analysis）：

A1）编译器将简单地将 “for each”循环翻译为带有迭代器的循环；
A2）for each循环可以与任何实现了 Iterator接口的对象一起工作，这个接口只包含一个方法：

public interface Iterable<E>
{Iterator<E> iterator();
}

Attention）Collection接口扩展了 Iterable 接口，因此，对于标准类库中的任何集合都可以使用 for each；

2.2.3）元素被访问的顺序取决于集合类型
- 2.2.3.1）如果对 ArrayList进行迭代，迭代器将从索引0开始；
- 2.2.3.2）如果访问 HashSet中的元素，每个元素将会按照某种随机的次序出现；虽然可以确定在迭代过程中能够遍历到集合中的所有元素，但却无法预知元素被访问的顺序；
  
  Annotation）编程老手会注意到： Iterator接口的next 和 hasNext方法与 Enumeration 接口的nextElement 和 hasMoreElements 方法的作用一样。 java集合类库的设计者可以选择使用Enumeration接口。但是，它们不喜欢这个接口累赘的方法名，于是引入了较短的方法名的新接口；
2.2.4）java迭代器：应该将java迭代器认为是位于两个元素之间，当调用next 方法时，迭代器就越过下一个元素，并返回刚刚越过的那个元素的引用；

Annotation）有用的类推：可以将Iterator.next 和 InputStream.read 看做是等效的。从数据流中读取一个字节，就会自动地消耗掉这个字节。下一次调用read将会消耗并返回输入的下一个字节。用同样的方式，反复地调用next 就可以读取集合中所有元素了；

2.3）删除元素

2.3.1）Iterator的remove方法将会删除上次调用next方法时返回的元素。在大多数情况下，在决定删除某个元素前应该先看一下这个元素是很具有实际意义的。然而，如果想要删除指定位置上的元素，仍然需要越过这个元素。
2.3.2）看个荔枝（如何删除集合中第一个元素）：

Iterator<String> it = c.iterator();
it.next(); // skip over the first element
it.remove(); // now remove it

你要记住，要删除某个元素，你得要先越过这个元素；
2.3.3）对next方法和 remove方法的调用具有相互依赖性。 如果调用 remove 之前没有调用next 将是不合法的。如果这样做，会抛出一个 IllegalStateException 异常；
2.3.4）看个荔枝： 如果想删除两个相邻元素，不能直接这样调用：

it.remove();
it.remove(); //ERROR
正确的方法是：
it.remove();
it.next();
it.remove();

2.4）泛型使用方法
* 2.4.1）由于Collection 和 Iterator 都是泛型接口，可以编写操作任何集合类型的实用方法。看个荔枝：下面是一个检测任意寄贺卡是否包含指定元素的泛型方法：

public static<E> boolean contains(Collection<E> e, Object obj)
{for(E element : c)if(element.equals(obj))return true;return false;
}

2.4.2）事实上， Collection接口声明了很多有用的方法，所有的实现类都必须提供这些方法，下面列举了部分：

int size()
boolean isEmpty()
boolean contains(Object obj)
boolean containsAll(Collection<?> c)： 这个集合包含other 集合中的所有元素，则返回true；
boolean equals(Object other)
boolean addAll(Collection<? extends E> from)
boolean remove(Object obj)
boolean removeAll(Collection<?> c)
void clear() ：移除集合中的所有元素；
boolean retainAll(Collection<?> c) ： 从集合中移除所有与 other 集合中的元素不同的元素。如果这个调用改变了集合，返回true；
Object[] toArray(); ： 返回这个集合的对象数组；
<T> T[] toArray(T[] arrtyToFill[])： 返回这个集合的对象数组。如果arrayToFill 数组足够大， 就将集合中的元素填入这个数组中。 剩余空间填补 null ； 否则， 分配一个新数组， 其成员类型与 arrayToFill 的成员类类型相同， 其长度等于集合的大小， 并添入集合元素；

2.4.3）AbstractCollection：当然，如果实现 Collection接口的每个类都要提供如此多的例行方法是一件很烦人的事情。为了能够让实现者更容易地实现这个接口，java类库提供了一个类 AbstractCollection ，它将基础方法 size 和 iterator 抽象化了；
（我的理解为：抽象类AbstractCollection实现部分的例行方法，其他可变的方法交给用户去实现）

public abstract class AbstractCollection<E> implements Collection<E>
{...public abstract Iterator<E> iterator();public boolean contains(Object obj){for(E element: this) // calls iterator()if(element.equals(obj))return true;return false;}......
}

对以上代码的分析（Analysis）：

A1）一个具体集合类可以扩展 AbstractCollection类了；
A2）现在要由具体的集合类提供 iterator 方法，而 contains 方法已由 AbstractCollection超类提供了；