数据结构模式

数据结构模式

       常常有一些组件在内部具有特定的数据结构，如果让客户程序依赖这些特定的数据结构，将极大地破坏组件的复用。这时候，将这些特定数据结构封装在内部，在外部提供统一的接口，来实现与特定结构无关的访问，是一种行之有效的解决方案。

一、Composite组合模式

        当客户代码过多依赖于对象容器复杂的内部结构，对象容器内部实现结构（而非抽象接口）的变化将引起客户代码的频繁变化，带来了代码的维护性、扩展性等弊端。Composite模式将“客户代码与复杂的对象容器结构”解耦，让对象容器自己来实现自身的复杂结构，从而使得客户代码就像处理简单对象一样来处理复杂的对象容器。

示例代码：

public abstract class Component {

    public abstract void process();

}

//树节点
public class Composite extends Component {

    String name;
    Vector<Component> elements;

    public Composite(String s) {
        name = s;
    }

    public void add(Component element) {
        elements.add(element);
    }

    public void remove(Component element) {
        elements.remove(element);
    }

    @Override
    public void process() {
        //1. process current node

        //2. process leaf nodes
        for (Component e  : elements) {
            e.process();//多态调用
        }
    }
}

//叶子节点
public class Leaf extends Component {
    String name;

    public Leaf(String s) {
        name = s;
    }

    @Override
    public void process() {
        //process current node
    }
}



public class  ClientApp{

    public static void invoke(Component c){
        //...
        c.process();
        //...
    }


    public static void main(String args[]) {

        Composite root=new Composite("root");
        Composite treeNode1=new Composite("treeNode1");
        Composite treeNode2=new Composite("treeNode2");
        Composite treeNode3=new Composite("treeNode3");
        Composite treeNode4=new Composite("treeNode4");
        Leaf leat1=new Leaf("left1");
        Leaf leat2=new Leaf("left2");

        root.add(treeNode1);
        treeNode1.add(treeNode2);
        treeNode2.add(leaf1);

        root.add(treeNode3);
        treeNode3.add(treeNode4);
        treeNode4.add(leaf2);

        invoke(root);
        invoke(leaf2);
        invoke(treeNode3);
    }

}

        将对象组合成树形结构以表示“部分-整体”的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性（稳定）。模式的结构如下图：

        ●  Composite模式采用树形结构来实现普遍存在的对象容器，从而将“一对多”的关系转化成“一对一”的关系，使得客户代码可以一致的（复用）处理对象和对象容器，无需关心处理的是单个对象，还是组合的对象容器；

        ●  将“客户代码与复杂的对象容器结构”解耦是Composite的核心思想，解耦之后，客户代码将与纯粹的抽象接口（而非对象容器的内部实现）发生依赖，从而更能“应对变化”；

        ●  Composite模式在具体实现中，可以让父对象中的子对象反向追溯；如果父对象有频繁的遍历需求，可使用缓存技巧来改善效率。

二、Iterator迭代器

        在软件构建过程中，集合对象内部结构常常变化各异。但对于这些集合对象，我们希望在不暴露其内部结构的同时，可以让外部客户代码透明地访问其中包含的元素；同时这种“透明遍历”也为“同一种算法在多种集合对象上进行操作”提供了可能。使用面向对象技术将这种遍历机制抽象为“迭代器对象”为“应对变化中的集合对象”提供了一种优雅的方式。

        定义：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露（稳定）该对象的内部表示。

示例代码：

public class  ClientApp{

    public static void main(String args[]) {

        Vector<String> mc=new Vector<>();
        mc.add("Beijing");
        mc.add("Shanghai");
        mc.add("New York");
        mc.add("Paris");
        mc.add("London");


        Iterator<String> iter = mc.iterator();

        while (iter.hasNext())
        {
            String item =  iterator.next();
            System.out.println(item);
        }


        for(String data: mc){
            System.out.println(data);
        }
    }

}

        迭代抽象：访问一个聚合对象的内容而无需暴露它的内部表示。

        迭代多态：为遍历不同的集合结构提供一个统一的接口，从而支持同样的算法在不同的集合结构上进行操作。

        迭代器的健壮性考虑：遍历的同时更改迭代器所在的集合结构，会导致问题。