转载

Iterator和Iterable

  1. Iterator:迭代器(接口),提供了统一的语法进行集合对象遍历操作.

    主要方法:

    hasNext() --判断是否还有下一个对象,如果有,则返回true,否则false;

    next() --返回集合的下个值,此方法只能在hasNext方法返回true时调用;

    remove() --删除集合的当前值,此方法也只能在hasNext方法返回true时调用

  2. Iterable:该接口是为了foreach循环设计的,只有一个方法表示可以返回Iterator对象,最终还是使用Iterator遍历;所有Collection集合都实现了该接口,可直接foreach遍历。

  3. 例子

  • 遍历集合
public static void main(String[] args) {
		List<Integer> li = new ArrayList<>();
		LinkedList<String> strings = new LinkedList<>();
		li.add(1);
		li.add(2);
		li.add(3);

		/*for (Integer integer : li) {
			System.out.println(integer);
		}*/
		Iterator<Integer> iter = li.iterator();

		while (iter.hasNext()){
			System.out.print(iter.next());
			iter.remove();//会删除原集合元素
		}
    }
复制代码
  • 让自己的类支持迭代

    Iterator和Iterable
  • No1:

public class Main {
	public static void main(String[] args) {
		MyString ss=new MyString("123");
		for (Character c:ss){
			System.out.print(c);
		}
    }
}
复制代码
class MyString implements Iterable<Character>{

    private int length=0;
    private String str="";
    public MyString(String str){
        this.str=str;
        this.length=str.length();
    }

    @Override
    public Iterator<Character> iterator() {
        return new Iter();
    }

    class Iter implements Iterator<Character>{
        private int curr=0;

        @Override
        public boolean hasNext() {
            return curr!=length;
        }

        @Override
        public Character next() {
            Character c=str.charAt(curr);
            curr++;//后移
            return c;
        }
    }
}
复制代码
  • No2: 遍历栈
public class Test {
public static void main(String[] args)throws Exception {
    Stack<String> stack = new Stack<>();
    stack.push("a");
    stack.push("b");
    stack.push("c");
    stack.push("d");

    for (String str : stack) {
    System.out.print(str+" ");
    }  

    System.out.println("-----------------------------");

    String result = stack.pop();
    System.out.println("弹出了元素:"+result);
    System.out.println(stack.size());
    }
}
复制代码
public class Stack<T> implements Iterable<T>{
    //记录首结点
    private Node head;
    //栈中元素的个数
    private int N;
    public Stack() {
    head = new Node(null,null);
    N=0;
    }

    //判断当前栈中元素个数是否为0
    public boolean isEmpty(){
    return N==0;
    }

    //把t元素压入栈
    public void push(T t){
    Node oldNext = head.next;
    Node node = new Node(t, oldNext);
    head.next = node;
    //个数+1
    N++;
    }

    //弹出栈顶元素
    public T pop(){
    Node oldNext = head.next;
    if (oldNext==null){
        return null;
    }

    //删除首个元素
    head.next = head.next.next;
    //个数-1
    N--;
    return oldNext.item;
    }

    //获取栈中元素的个数
    public int size(){
    return N;
    }

    @Override
    public Iterator<T> iterator() {
    return new SIterator();
    }

    private class SIterator implements Iterator<T>{
        private Node n = head;

        @Override
        public boolean hasNext() {
        return n.next!=null;
        }

        @Override
        public T next() {
        Node node = n.next;
        n = n.next;
        return node.item;
        }
      }

    private class Node{
        public T item;
        public Node next;
        public Node(T item, Node next) {
            this.item = item;
            this.next = next;
        }
     }
  }
复制代码
原文  https://juejin.im/post/5e8eb860518825736c5b8cf6
正文到此结束
Loading...