一、迭代器模式
迭代器模式可能是JAVA中最广为人知的模式之一,JAVA程序员在使用集合时,并不需要关注其类型是List、Set还是其他的,因为它们的遍历都可以通过迭代器来完成。迭代器模式在客户访问类和聚合类之间插入,分离了聚合对象与其遍历行为,对客户也隐藏了其内部细节,满足单一职责原则和开闭原则。
- 抽象聚合(Aggregate): 也叫抽象容器,定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
- 具体聚合(ConcreteAggregate): 也叫具体容器,实现内部不同结构,返回一个迭代器实例。
- 抽象迭代器(Iterator): 定义访问和遍历聚合元素的接口。
- 具体迭代器(ConcreteIterator): 实现抽象迭代器接口中的方法,完成对聚合对象的遍历,记录遍历的当前位置。
二、迭代器模式实现方式
1、抽象迭代器
我们可以直接使用 JDK 自带的 Iterator 接口,如果不满足自己的需求也可以按照自己的需求自己创建一个。这里我是有的是JDK 自带的 Iterator 接口,我们将源码粘贴过来。
public interface Iterator<E> {
boolean hasNext();
//使用泛型 E
E next();
default void remove() {
throw new UnsupportedOperationException("remove");
}
default void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
while (hasNext())
action.accept(next());
}
}
2、具体迭代器:
@Data
public class Phone {
public String name;
public String money;
}
//List 集合包装为 Iterator 遍历的对象
public class ListIterator implements Iterator<Object>{
//定义一个 List 集合
List<Phone> list;
//构造器
public ListIterator(List<Phone> list) {
this.list = list;
}
//获取位数
int index = 0;
@Override
public boolean hasNext() {
if(list != null && list.size()>index) {
return true;
}else {
return false;
}
}
@Override
public Object next() {
Phone object = list.get(index);
index+=1;
return object;
}
}
//数组集合包装为 Iterator 遍历的对象
public class ArrayIterator implements Iterator<Object>{
//定义 电话数组
Phone[] phones;
//下标
private int index = 0;
//构造器
public ArrayIterator(Phone[] phones) {
this.phones = phones;
}
@Override
public boolean hasNext() {
if(phones[index] != null && phones.length > index) {
return true;
}else {
return false;
}
}
@Override
public Object next() {
Phone phone = phones[index];
index+=1;
return phone;
}
}
3、 抽象聚合角色
public interface Aggregate {
//获取手机名称
public String getName();
//创建一个获取 Iterator 实例的方法
public Iterator<Object> createIterator();
//增加手机的方法
public void add(String name,String type);
}
4、具体聚合角色
public class XiaoMiPhone implements Aggregate{
//小米使用 list 存储产品
private List<Phone> xiaoMis = new ArrayList<Phone>();
//构造器
public XiaoMiPhone() {
add("红米", "1200");
add("小米6", "2300");
add("小米7", "3200");
}
@Override
public String getName() {
return "====小米手机====";
}
//创建遍历器
@Override
public Iterator<Object> createIterator() {
return new ListIterator(xiaoMis);
}
//集合中添加小米产品
@Override
public void add(String name, String money) {
xiaoMis.add(new Phone(name, money));
}
}
public class HuaWeiPhone implements Aggregate{
//存储华为手机的数据
Phone phone[];
private int index = 0;
//构造器
public HuaWeiPhone() {
phone = new Phone[5];
add("荣耀", "1300");
add("华为P8", "2000");
add("华为P20", "8000");
}
@Override
public String getName() {
return "====华为手机====";
}
@Override
public Iterator<Object> createIterator() {
return new ArrayIterator(phone);
}
@Override
public void add(String name, String money) {
phone[index] = new Phone(name,money);
index +=1;
}
}
5、构造一个数据的工厂类(非必须的,我这里是方便测试添加的)
public class Output {
//定义一个集合
private List<Aggregate> phones;
//构造器
public Output(List<Aggregate> phones) {
this.phones = phones;
}
//输入方法
public void outPrit() {
//先调用 list 自身带的迭代器 Iterator
Iterator<Aggregate> iterator = phones.iterator();
// 调用hasNext 方法
while(iterator.hasNext()) {
Aggregate aggregate = iterator.next();
//手机品牌名称
System.out.println(aggregate.getName());
//遍历品牌的所有手机,使用我们自己实现的Iterator
pritlnPhone(aggregate.createIterator());
}
}
private void pritlnPhone(Iterator<Object> createIterator) {
while(createIterator.hasNext()) {
Phone phone = (Phone) createIterator.next();
System.out.println("品牌="+phone.getName()+"-----金额="+phone.getMoney());
}
}
}
6、测试
public class Client {
public static void main(String[] args) {
//手机店集合
List<Aggregate> phones = new ArrayList<>();
//创建华为手机 == 数组
HuaWeiPhone huaWeis = new HuaWeiPhone();
//创建小米手机 == list
XiaoMiPhone xiaoMis = new XiaoMiPhone();
//将其都加入到手机店集合
phones.add(huaWeis);
phones.add(xiaoMis);
//调用公共的输入类
Output output = new Output(phones);
output.outPrit();
/**
* 结构如下:
* ====华为手机====
品牌=荣耀-----金额=1300
品牌=华为P8-----金额=2000
品牌=华为P20-----金额=8000
====小米手机====
品牌=红米-----金额=1200
品牌=小米6-----金额=2300
品牌=小米7-----金额=3200
*/
}
}
三、迭代器模式应用源码分析
分析一下 arrayList 的 iterator 的使用
1、先了解下 ArrayList 的 Iterator 的使用:
public class IteratorDemo {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("t");// ..
// 获取到迭代器
Iterator<String> Itr = list.iterator();
while (Itr.hasNext()) {
System.out.println(Itr.next());
}
}
}
2、进入 ArrayList(相当于具体聚合对象)的源码:实现了 List 接口,实现了 Iterator 方法,返回遍历对象:Iterator。
public class ArrayList<E> extends AbstractList<E>
implements List<E>
{
...
public Iterator<E> iterator() {
return new Itr();
}
...
}
3、进入 List(相当于抽象聚合对象) 接口查看:发现包含一个 Iterator 的抽象方法 。
public interface List<E> extends Collection<E> {
...
Iterator<E> iterator();
...
}
4、我们进入返回的 Iterator 对象的类 Itr (相当于具体的迭代器),是 ArraList 类的内部类。查看 hasNext()方法,会发现遍历的对象是 Object[] 数组,具体的迭代器类(实现 hasNext 和 Next 方法)
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();
}
}
......
}
5、上述具体迭代器角色实现了 Iterator 接口,也就是抽象迭代器角色。与我们的案例中实现同一个接口,就不展示了。
四、迭代器模式总结
优点
- 访问一个聚合对象的内容而无须暴露它的内部表示。
- 遍历任务交由迭代器完成,这简化了聚合类。
- 它支持以不同方式遍历一个聚合,甚至可以自定义迭代器的子类以支持新的遍历。
- 增加新的聚合类和迭代器类都很方便,无须修改原有代码。
- 封装性良好,为遍历不同的聚合结构提供一个统一的接口
缺点:
- 由于迭代器模式将存储数据和遍历数据的职责分离,增加新的聚合类需要对应增加新的迭代器类,类的个数成对增加,这在一定程度上增加了系统的复杂性。
应用场景
- 访问一个聚合对象的内容而无须暴露它的内部表示。
- 需要为聚合对象提供多种遍历方式。
- 为遍历不同的聚合结构提供一个统一的接口。