设计模式原来这么简单-迭代器模式

迭代器模式

1.什么时迭代器模式

在不暴露集合对象内部实现的前提下顺序的对该集合的元素进行访问

2.实例

存在一个公司，公司里有员工，现在需要对公司内的员工进行遍历

3.程序实例

public class Company {

    private Employee[] employeeList;

    public Company(Employee[] employeeList){
       this.employeeList = employeeList;
    }

    public Iterator<Employee> iterator(){
        return new CompanyIterator(this);
    }

    public Iterator<Employee> typeIterator(Employee.Type type){
        return new CompanyTypeIterator(this, type);
    }

    public Employee[] getEmployeeList() {
        return employeeList;
    }

    public boolean addEmployee(Employee employee){
        // ...
        return true;
    }

    public boolean removeEmployee(Employee employee){
        // ...
        return true;
    }
}

@Data
@AllArgsConstructor
public class Employee {

    private String name;

    private Type type;

    public enum Type{
        CHARGE,COMMON
    }
}

public interface Iterator<T> {

    boolean hasNext();

    T next();
}

public abstract class BaseCompanyIterator implements Iterator<Employee>{

    protected Company company;
    protected int cursor = -1;

    public BaseCompanyIterator(Company company){
        this.company = company;
    }

    @Override
    public Employee next() {
        cursor = findNextCursor();
        if (cursor != -1) {
            return company.getEmployeeList()[cursor];
        }
        return null;
    }

    @Override
    public boolean hasNext() {
        return findNextCursor() != -1;
    }

    protected abstract int findNextCursor();
}

简单顺序遍历

public class CompanyIterator extends BaseCompanyIterator{

    public CompanyIterator(Company company) {
        super(company);
    }

    @Override
    protected int findNextCursor() {
        Employee[] employeeList = company.getEmployeeList();
        int tempCursor = cursor;
        tempCursor++;
        if (tempCursor >= employeeList.length) {
            return  -1;
        }
        return tempCursor;
    }
}

按类型进行遍历

public class CompanyTypeIterator extends BaseCompanyIterator{
    private Employee.Type type;

    public CompanyTypeIterator(Company company, Employee.Type type){
        super(company);
        this.type = type;
    }

    @Override
    protected int findNextCursor() {
        Employee[] employeeList = company.getEmployeeList();
        int tempIndex = cursor;
        while (true){
            tempIndex++;
            if(tempIndex >= employeeList.length){
                tempIndex = -1;
                break;
            }
            if(type.equals(employeeList[tempIndex].getType())){
                break;
            }
        }
        return tempIndex;
    }
}

4.测试

@Test
public void testIterator(){
    Iterator<Employee> iterator = company.iterator();

    while (iterator.hasNext()){
        System.out.println(iterator.next().getName());
    }
}

zs
ls
ww

@Test
public void testTypeIterator(){
    Iterator<Employee> iterator = company.typeIterator(Employee.Type.CHARGE);
    while (iterator.hasNext()){
        System.out.println(iterator.next().getName());
    }
}

zs

5.总结

该模式适合在希望实例的遍历行为和该类解耦时使用