Iterator
行为模式
它把对容器中包含的内部对象的访问委让给外部类,使用Iterator(遍历)按顺序进行遍历访问的设计模式。
角色和职责:
Iterator(迭代器接口):该接口必须实现迭代功能的最小定义方法集,比如提供hashNext(),next()方法
ConcreteIterator(迭代器实现类):迭代器接口Iterator的实现类。可以根据具体情况加以实现,需要得到内部信息,所以作为内部类
Aggregate(容器接口):定义基本功能以及提供类似Iterator()的方法。
concreteAggregate(容器实现类):容器接口的实现类。必须实现Iterator()方法。
优点:
1.实现功能分离,简化容器接口。让容器只实现本身的基本功能,把迭代功能委让给外部类实现,复合类的设计原则。
2.隐藏容器的实现细节。
3.为容器或其子容器提供了一个统一接口,一方面方便调用;另一方面使得调用者不必关注迭代器的实现细节。
4.可以为容器或其子容器实现不同的迭代方法或多个迭代方法。
//pojo
public class Book {
private String ISBN;
private String name;
private double price;
public Book(String ISBN, String name, double price) {
this.ISBN = ISBN;
this.name = name;
this.price = price;
}
@Override
public String toString() {
return "Book{" +
"ISBN='" + ISBN + '\'' +
", name='" + name + '\'' +
", price=" + price +
'}';
}
public String getISBN() {
return ISBN;
}
public void setISBN(String ISBN) {
this.ISBN = ISBN;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
}
//concreteAggregate(容器实现类)
public class BookList {
private List<Book> bookList;
private int index;//遍历到哪一个
private Iterator iterator;
public BookList(){
bookList = new ArrayList<>();
}
//添加书籍
public void addBook(Book book){
bookList.add(book);
}
//删除书籍
public void deleteBook(Book book){
int bookIndex = bookList.indexOf(book);//找到相关对象的索引
bookList.remove(bookIndex);
}
/* //判断是否有下一本书
public boolean hashNext(){
if(index >= bookList.size()){
return false;
}
return true;
}
//获得下一本书
public Book getNext(){
return bookList.get(index++);
}*/
public Iterator iterator(){
return new Itr();
}
private class Itr implements Iterator{
@Override
public boolean hasNext() {
if(index >= bookList.size()){
return false;
}
return true;
}
@Override
public Object next() {
return bookList.get(index++);
}
@Override
public void remove() {
}
@Override
public void forEachRemaining(Consumer action) {
}
}
}
public class MainClass {
public static void main(String[] args) {
BookList bookList = new BookList();
Book book1 = new Book("1","Java编程",90);
Book book2 = new Book("2","Java思想",90);
Book book3 = new Book("3","Java入门到放弃",90);
bookList.addBook(book1);
bookList.addBook(book2);
bookList.addBook(book3);
/*while(bookList.hashNext()){
System.out.println(bookList.getNext());
}*/
Iterator iterator = bookList.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
我们可以看下ArrayList的Iteraotr实现
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
@Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> consumer) {
Objects.requireNonNull(consumer);
final int size = ArrayList.this.size;
int i = cursor;
if (i >= size) {
return;
}
final Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
consumer.accept((E) elementData[i++]);
}
// update once at end of iteration to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}