Iterator模式 --一个一个遍历
示例程序
- Aggregate接口
Aggregate接口是索要遍历的集合的接口。实现了该接口的类将称为一个可以保持多个元素的集合。
public interface Aggregate {
public abstract Iterator iterator();
}Aggregate接口中的iterator 方法将会生成一个用于遍历集合的迭代器。想要遍历集合中的元素的时候可以调用该方法来生成一个实现了Iterator接口的类的实例。
- Iterator接口
public interface Iterator {
public abstract boolean hasNext();
public abstract Object next();
}hasNext()方法主要用于循环终止条件。
next()方法用于返回集合中的一个元素，并且为了在下次调用next方法时正确地反回下一个元素，在该方法中还需将迭代器移动至下一个元素的处理。
- Book类
public class Book {
private String name;
public Book(String name) {
this.name = name;
}
public String getName() {
return name;
}
}- BookShelf类
public class BookShelf implements Aggregate {
private Book[] books;
private int last = 0;
public BookShelf(int maxsize) {
this.books = new Book (maxSize);
}
public Book getBookAt(int index){
return books[index];
}
public void appendBook(Book book) {
this.books[last] = book'
last++;
}
public int getLength() {
return last;
}
public Itrator iterator() {
return new BookShelfIterator(this);
}
}BookShelf类是用来表示书架的类，将该类作为Book的集合进行处理，实现了Aggregate接口。
- BookShelfIterator类
public class BookShelfIterator implements Iterator {
private BookShelf bookShelf;
private int index;
public BookShelfIterator(BookShelf bookShelf) {
this.bookShelf = bookShelf;
this.index = 0;
}
public boolean hasNext(){
if(index < bookShelf.getLength()){
return true;
} else {
return false;
}
}
public Object next(){
Book book = bookShelf.getBookAt(index);
index++;
return book;
}
}BookShelfIterator类是一个迭代器的实现，它持有一个将要遍历的集合BookShelf书架。
- Main类
public class Main{
public static void main(String[] args) {
BookShelf bookShelf = new BookShelf(4);
bookShelf.appendBook(new Book("倚天屠龙记"));
bookShelf.appendBook(new Book("葵花宝典"));
bookShelf.appendBook(new Book("九阳真经"));
bookShelf.appendBook(new Book("神雕侠侣"));
Iterator it = bookShelf.iterator();
while (it.hasNext()){
Book book = (Book) it.next();
System.out.println(book.getName());
}
}
}总结
- 为何要使用Iterator
引入Iterator后可以将遍历与实现分离开来，在遍历时只需调用迭代器的方法，而不用关心具体集合实现类的方法。假设以后需要对集合类的实现方式进行修改，只要集合中的Iterator方法能正确的返回Iterator实例，即使不对迭代器的使用者进行修改，遍历代码都能正常工作。
设计模式的作用就是帮助我们编写可复用的类。“可复用”就是将类实现为“组件”，当一个组件发生改变时，不需要对其他的组件进行修改或只需很小的修改即可应对。
- 多个Iterator
将遍历功能置于Aggregate角色之外，是Iterator模式的一个特征。根据这几个特征，可以针对一个具体的ConcreateAggregate角色编写多个ConcreteIterator角色。
- 对JAVA集合进行遍历删除时务必要用迭代器。
private class Itr implements Iterator<E> {
/**
* Index of element to be returned by subsequent call to next.
*/
int cursor = 0;
/**
* Index of element returned by most recent call to next or
* previous. Reset to -1 if this element is deleted by a call
* to remove.
*/
int lastRet = -1;
/**
* The modCount value that the iterator believes that the backing
* List should have. If this expectation is violated, the iterator
* has detected concurrent modification.
*/
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size();
}
public E next() {
checkForComodification();
try {
E next = get(cursor);
lastRet = cursor++;
return next;
} catch (IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
public void remove() {
if (lastRet == -1)
throw new IllegalStateException();
checkForComodification();
try {
AbstractList.this.remove(lastRet);
if (lastRet < cursor)
cursor--;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}ArrayList中的迭代器实现