java 设计模式 Iterator 容器与容器遍历

容器 ，不用考虑边界（动态扩展），并且知道长度

所有的容器里都有一个加入方法，和一个 求长度方法

先设定指定大小的数组，一旦装满了，再开辟新的一块空间再继续装

可以用数组或者 链表来实现：

数组实现：

Object[] objects = new Object[10];
int index = 0;

public void add(Object o) {
if (index == objects.length) {
Object[] newObjects = new Object[objects.length * 2];
System.arraycopy(objects, 0, newObjects, 0, objects.length);
objects = newObjects;
}
objects[index] = o;
index++;
}

public int size() {
return index;
}

在同一个包里的java 文件会被优于系统类 被优先引用

链表实现:

Node head = null;
Node tail = null;
int size = 0;


public void add(Object o) {
Node n = new Node(o, null);
if (head == null) {
head = n;
tail = n;
} else {
tail.setNext(n);
tail = n;
size++;
}
}


public int size() {
return size;
}

容器的可替换性

申明一个接口 Collection ，里面有两个方法申明 一个add  一个 size

让容器类实现这个接口，并重写这两个方法

写法：

Collection c =new 对应容器类（）;//  这里就体现了容器的可替换性，不用考虑具体的实现类

其他地方都统一了，都不用变，直接用c.add(o)  和 c.size()  方法即可

可替换性的遍历方式：

统一遍历方式

申明遍历方式的接口Iterator  ，里面有两个“函数申明” 一个是返回下一个对象 next()，一个 是否有下一个对象 hasNext()

写法：

在接口Collection 里头 定义返回值为Iterator 的iterator 方法

（所有容器类型必须实现这个Iterator 接口 并且重写里头两个方法）

这里换一种写法，写成内部类，然后用内部类实现这个Iterator 接口 并且重写里头两个方法，用的使用用这个内部类实例化然后调用方法

写法：

@Override

public Iterator iterator() {
//如果用单利模式甚至都不用new 直接用单例模式放这儿就可以了
return new ArrayListIterator();
}


//也可以通过匿名类来实现，或者像这样用内部类实现 
private class ArrayListIterator implements Iterator {


private int currentIndex = 0;


@Override
public Object next() {
// TODO Auto-generated method stub
Object o=objects[currentIndex];
currentIndex++;
return o;
}


@Override
public boolean hasNext() {


// TODO Auto-generated method stub
if (currentIndex >= index) {
return false;
} else
return true;
}
}

最后写法：

然后在主方法里写 Iterator it=c .iterator(); //因为所有的容器类都实现了Iterator 接口，重写了Iterator 里的方法

遍历方式

while(it.hasNext()){
Object o=it.next();
System.out.println(o.toString()+" ");
}

泛型，就是在类申明后面带上<E>  然后把所有和类变量相关的具体类型的地方 全部替换成E 就可以了

用的时候在类实例化的地方，直接把E 替换成具体类型就可以了

补上链表的实现Iterator接口方法

@Override
public Iterator iterator() {
// 如果用单利模式甚至都不用new 直接用单例模式放这儿就可以了
return new LinkedListIterator();
}


// 也可以通过匿名类来实现，或者像这样用内部类实现
// java中的内部类和接口加在一起，可以实现多继承。
// 可以使某些编码根简洁。
// 隐藏你不想让别人知道的操作。
private class LinkedListIterator implements Iterator {


private Node index = head;


@Override
public Object next() {
// TODO Auto-generated method stub
if (index!= null) {
Object o=index.getData();
index=index.getNext();
return o;
} else
return null;
}


@Override
public boolean hasNext() {


// TODO Auto-generated method stub
if (index!= null) {
return true;
} else
return false;
}
}
}