迭代器模式可以说经常在用，也可以说不常用，他一般用在集合里面的遍历。（JDK已经帮我们实现了，所以我们经常用别人写好的，只是不知道而已）
计算机的物理存储，只分为2个类型，随机存储，顺序存储，JAVA里的集合的典型代表是ArrayList,LinkList,他们的遍历方式是不同的，如果外部类想要对他们进行遍历的话，不同的集合要写不同的算法，迭代器模式就是解决这个问题（集合你自己去实现好遍历，我外部只管调用你提供方法就好了）
第一步，手写ArrayList,LinkList源码实现,首先抽离公共接口为Collection_
public interface Collection_ {
void add(Object o);
int size();
}
arraylist 底层是顺序存储，所以用数组来存
public class ArrayList_ implements Collection_{
private Object[] objects = new Object[10];//初始化一个10个大小数组
private int index=0;//记录数组大小，同时也当下标使用
@Override
public void add(Object o) {
if(index>=objects.length){
//如果放置的元素最后一个时候，那么先扩容为2倍
Object[] newobjects = new Object[objects.length*2];
System.arraycopy(objects,0,newobjects,0,objects.length);
objects=newobjects;
}
objects[index]=o;
index++;
}
@Override
public int size() {
return index;
}
}
linklist 采用链表形式，先造一个Node类来包装，也就是所谓的单个链条元素
public class Node {
private Object object;
private Node next;
public Node(Object object) {
this.object = object;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
}
public class LinkList_ implements Collection_{
Node head=null;//头指针
Node tail=null;//尾指针
int size=0;
@Override
public void add(Object o) {
Node node= new Node(o);//链表需要Node包裹对象
if(head==null){
//如果头指针没用持对象，当作是空表
head=node;
tail=node;
}
tail.setNext(node); //旧的尾节点保存下一个节点的信息，把新节点加进来
tail=node;//tail节点离开旧节点，指向新加进来的node
size++;//长度增加
}
@Override
public int size() {
return size;
}
}
本期主题是迭代器模式，就是要遍历集合内元素，但是这些集合写法不一样，不能统一到一个共同方法，但是可以让他们都继承一个接口，在接口里面他们自己去实现，外面的人只管调用他们继承的接口，不管他们的内部是怎么实现的
//新增接口
public interface Iterator_ {
boolean hasNext();
Object next();
}
//调整接口
public interface Collection_<E> {
void add(E o);
int size();
Iterator_ iterator();
}
修改后array和link
public class ArrayList_ implements Collection_{
private Object[] objects = new Object[10];//初始化一个10个大小数组
private int index=0;//记录数组大小，同时也当下标使用
@Override
public void add(Object o) {
if(index>=objects.length){
//如果放置的元素最后一个时候，那么先扩容为2倍
Object[] newobjects = new Object[objects.length*2];
System.arraycopy(objects,0,newobjects,0,objects.length);
objects=newobjects;
}
objects[index]=o;
index++;
}
@Override
public int size() {
return index;
}
@Override
public Iterator_ iterator() {
return new ArrayListIterator();
}
private class ArrayListIterator implements Iterator_ {
private int currentindex=0;//当前索引
@Override
public boolean hasNext() {
if(currentindex>=index)
return false;
return true;
}
@Override
public Object next() {
Object object = objects[currentindex];
currentindex++;
return object;
}
}
}
public class MyLinkList implements ZCollection {
Node head = null;
Node tail = null;
private int size=0;
@Override
public void add(Object o) {
Node n=new Node(o);
if (head == null) {
head=n;
tail=n;
}
tail.setNext(n);
tail=n;
size++;
}
@Override
public int size() {
return size;
}
@Override
public Iterator_ interator() {
return new LinkListIterator();
}
private class LinkListIterator implements Iterator_ {
private int currentindex=0;
@Override
public boolean hasNext() {
if (currentindex >= size) {
return false;
}
return true;
}
@Override
public Object next() {
int offset=0;
Node check = check(offset, head);
currentindex++;
return check;
}
private Node check(int offset, Node node) {
if (offset == currentindex) {
return node;
}else{
return check(++offset,node.getNext());
}
}
}
}
为了更加和jdk 提供的array和link相像，把Object 对象统一换成泛型E
public interface Collection_<E> {
void add(E o);
int size();
Iterator_ iterator();
}
public interface Iterator_<E> {
boolean hasNext();
E next();
}
public class ArrayList_<E> implements Collection_<E>{
private E[] objects = (E[]) new Object[10];//初始化一个10个大小数组
private int index=0;//记录数组大小，同时也当下标使用
@Override
public void add(E o) {
if(index>=objects.length){
//如果放置的元素最后一个时候，那么先扩容为2倍
E[] newobjects = (E[]) new Object[objects.length*2];
System.arraycopy(objects,0,newobjects,0,objects.length);
objects=newobjects;
}
objects[index]=o;
index++;
}
@Override
public int size() {
return index;
}
@Override
public Iterator_ iterator() {
return new ArrayListIterator();
}
private class ArrayListIterator<E> implements Iterator_<E> {
private int currentindex=0;//当前索引
@Override
public boolean hasNext() {
if(currentindex>=index)
return false;
return true;
}
@Override
public E next() {
E object = (E) objects[currentindex];
currentindex++;
return object;
}
}
}
public class LinkList_<E> implements Collection_<E>{
Node head=null;//头指针
Node tail=null;//尾指针
int size=0;
@Override
public void add(E o) {
Node node= new Node(o);//链表需要Node包裹对象
if(head==null){
//如果头指针没用持对象，当作是空表
head=node;
tail=node;
}
tail.setNext(node); //旧的尾节点保存下一个节点的信息，把新节点加进来
tail=node;//tail节点离开旧节点，指向新加进来的node
size++;//长度增加
}
@Override
public int size() {
return size;
}
@Override
public Iterator_ iterator() {
return new LinkListIterator();
}
private class LinkListIterator implements Iterator_ {
private int currentindex=0;
@Override
public boolean hasNext() {
if (currentindex >= size) {
return false;
}
return true;
}
@Override
public Object next() {
int offset=0;
Node node = getNode(offset, head);
return node;
}
private Node getNode(int offset, Node node) {
if (offset == currentindex) {
//相等说明指定的就是要的节点，否则前进一步去拿下一个节点
return node;
}else{
return getNode(++offset,node.getNext());
}
}
}
}
最后场景类验证
public class Client {
public static void main(String[] args) {
Collection_<String> mytest=new ArrayList_<>();
for (int i = 0; i < 5; i++) {
mytest.add(i+"");
}
Iterator_ iterator = mytest.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.err.println(next);
}
}
}
网友评论