设计模式：迭代器模式

所谓迭代器就是针对任意类型的集合实现遍历的一种方法。
具体方法如下，我们先写一个自己的迭代器接口，里面有两个方法hasNext和next方法。让需要遍历的集合实现一个返回迭代器的方法，重写这两个方法。这里我们为了更好的理解集合的内部原理我自己写了一个可扩容的集合分别使用数组和链表作为底层。（所有的集合也都是以这两种物理结构作为底层的例如树，队列，栈，图都属于逻辑结构，在物理上只分为两种，一种是连续性存储也就是数组，一种是不连续性存储就是链表）
可扩容的数组

public class MyList  implements MyCollction{
    public Object []objects = new Object[10];
   static private int index = 0;

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

        return  objects[index++] = o ;
    }

    @Override
    public int size() {
        return index;
    }

    @Override
    public MyInterator interator() {

        return new MyInteratorImpl();
    }

    class MyInteratorImpl implements MyInterator  {
        int currentIndex = 0;
        @Override
        public boolean hasNext() {
            if (currentIndex<index)
            return true;
            else return false;
        }

        @Override
        public Object next() {
            return objects[currentIndex++];
        }
    }
}

链表

public class MyLinkList implements MyCollction{
    Node head;
    Node tail;
    private int index=0;

    public Object add (Object o){
        Node node = new Node(o);
        if(head==null){
            head=node;
            tail=node;
        }
        node.next=head;
        tail.next=node;
        tail=node;
        index++;
        return node;
    }
    class Node{
        Object object;
        Node next;

        @Override
        public String toString() {
            return "Node{" +
                    "object=" + object +
                    ", next=" + next.object +
                    '}';
        }

        public Node(Object object) {
            this.object = object;
        }
    }

    public int size(){
        return index;
    }

    @Override
    public MyInterator interator() {
        return new MyInteratorImpl();
    }
    class MyInteratorImpl implements MyInterator  {
        int currentIndex = 0;
        Node current = head;
        @Override
        public boolean hasNext() {
            boolean result = true;
                if (currentIndex==index) {
                    result=false;
            }
            return result;
        }


        @Override
        public Object next() {
                if(hasNext()){
                    currentIndex++;
                    Node now = current;
                    current= current.next;
                return now;
                }
            return current;
        }
    }

}

迭代器接口

public interface MyInterator {
    boolean hasNext();
    Object next();
}

集合的接口：集合如果是可迭代的就必须提供一个返回迭代器的方法interator()在里面重写自己内部的迭代逻辑。

public interface MyCollction {
Object add(Object o);
int size();
MyInterator interator();
}

测试

public class main {
//数组
//    public static void main(String[] args) {
//            MyCollction list=  new MyList();
//            list.add("11");
//            list.add("22");
//            list.add("33");
//            list.add("44");
//            list.add("55");
//            System.out.println(list.size());
//            MyInterator interator = list.interator();
//            while (interator.hasNext()){
//                System.out.println(interator.next());
//          }
//}


//链表
    public static void main(String[] args) {
            MyCollction list=  new MyLinkList();
            list.add("11");
            list.add("22");
            list.add("33");
            list.add("44");
            list.add("55");
            System.out.println(list.size());
            MyInterator interator = list.interator();
            while (interator.hasNext()){
                System.out.println(interator.next().toString());
          }
    }
}

这里记录一个奇怪的知识点：如果return a=b，a=b这条语句并不会被执行而是直接返回b的值

 public static void main(String[] args) {
        int a = 11,b=10;
        System.out.println(a(a,b));
        System.out.println(a);
        System.out.println(b);

    }
   static int a(int a,int b){
        return a=b;
    }

测试结果