Iterator
Iterator:迭代器，它是Java集合的顶层接口（不包括 map 系列的集合，Map接口 是 map 系列集合的顶层接口）

主要包含三种方法：

hasNext()是否还有下一个元素。
next()返回下一个元素。
remove()删除当前元素。

If you are just wandering over the collection to read all of the values, then there is no difference between using an iterator or the new for loop syntax, as the new syntax just uses the iterator underwater.

If however, you mean by loop the old “c-style” loop:

for(int i=0; i< list.size(); i++) { 

   Object o = list.get(i); 

} 

Then the new for loop, or iterator, can be a lot more efficient, depending on the underlying data structure. The reason for this is that for some data structures, get(i) is an O(n) operation, which makes the loop an O(n2) operation. A traditional linked list is an example of such a data structure. All iterators have as a fundamental requirement that next() should be an O(1) operation, making the loop O(n).

To verify that the iterator is used underwater by the new for loop syntax, compare the generated bytecodes from the following two Java snippets. First the for loop:

List  a = new ArrayList(); 

for (Integer integer : a) 

{ 

  integer.toString(); 

} 

// Byte code 

 ALOAD 1 

 INVOKEINTERFACE java/util/List.iterator()Ljava/util/Iterator; 

 ASTORE 3 

 GOTO L2 

L3 

 ALOAD 3 

 INVOKEINTERFACE java/util/Iterator.next()Ljava/lang/Object; 

 CHECKCAST java/lang/Integer 

 ASTORE 2  

 ALOAD 2 

 INVOKEVIRTUAL java/lang/Integer.toString()Ljava/lang/String; 

 POP 

L2 

 ALOAD 3 

 INVOKEINTERFACE java/util/Iterator.hasNext()Z 

 IFNE L3 

And second, the iterator:

List  a = new ArrayList(); 

for (Iterator iterator = a.iterator(); iterator.hasNext();) 

{ 

  Integer integer = (Integer) iterator.next(); 

  integer.toString(); 

} 

// Bytecode: 

 ALOAD 1 

 INVOKEINTERFACE java/util/List.iterator()Ljava/util/Iterator; 

 ASTORE 2 

 GOTO L7 

L8 

 ALOAD 2 

 INVOKEINTERFACE java/util/Iterator.next()Ljava/lang/Object; 

 CHECKCAST java/lang/Integer 

 ASTORE 3 

 ALOAD 3 

 INVOKEVIRTUAL java/lang/Integer.toString()Ljava/lang/String; 

 POP 

L7 

 ALOAD 2 

 INVOKEINTERFACE java/util/Iterator.hasNext()Z 

 IFNE L8 

As you can see, the generated byte code is effectively identical, so there is no performance penalty to using either form. Therefore, you should choose the form of loop that is most aesthetically appealing to you, for most people that will be the for-each loop, as that has less boilerplate code.

for-each is syntactic sugar for using iterators (approach 2).

You might need to use iterators if you need to modify collection in your loop. First approach will throw exception.

for (String i : list) { 

    System.out.println(i); 

    list.remove(i); // throws exception     modCount 和 expectedModCount不一致 

} 

Iterator it=list.iterator(); 

while (it.hasNext()){ 

    System.out.println(it.next()); 

    it.remove(); // valid here 

}

//打印并删除 

  for (int i = 0; i < a.size(); i++) { 

            System.out.println(a.get(i)); 

            a.remove(i); 

  }   //不会报错，但影响结果，可以从后往前删

分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 

Definition

Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.

Participants

    The classes and/or objects participating in this pattern are:

Iterator (AbstractIterator)

	
Defines an interface for accessing and traversing elements
	
	
ConcreteIterator (Iterator)
	
Implements the Iterator interface
		
Keeps track of the current position in the traversal of the aggregate
	
	
Aggregate (AbstractCollection)
	
Defines an interface for creating an Iterator object
	
	
ConcreteAggregate (Collection)
	
Implements the Iterator creation interface to return an instance of the proper ConcreteIterator
	
Sample Code in C#

This structural code demonstrates the Iterator pattern which provides for a way to traverse (iterate) over a collection of items without detailing the underlying structure of the collection.

/*
 * Structural Iterator Design Pattern.
 */

using System;
using System.Collections;

namespace Iterator.Sample
{
    /// <summary>
    /// Startup class for Structural Iterator Design Pattern.
    /// </summary>
    internal static class Program
    {
        #region Methods

        /// <summary>
        /// Entry point into console application.
        /// </summary>
        private static void Main()
        {
            var a = new ConcreteAggregate {[0] = "Item A", [1] = "Item B", [2] = "Item C", [3] = "Item D"};

            // Create Iterator and provide aggregate.
            var i = new ConcreteIterator(a);
            Console.WriteLine("Iterating over collection:");
            var item = i.First();
            while (item != null)
            {
                Console.WriteLine(item);
                item = i.Next();
            }
        }

        #endregion
    }

    /// <summary>
    /// The 'Aggregate' abstract class.
    /// </summary>
    internal abstract class Aggregate
    {
        #region Public Methods and Operators

        /// <summary>
        /// Create iterator.
        /// </summary>
        /// <returns>
        /// The <see cref="Iterator"/>.
        /// </returns>
        public abstract Iterator CreateIterator();

        #endregion
    }

    /// <summary>
    /// The 'ConcreteAggregate' class.
    /// </summary>
    internal class ConcreteAggregate : Aggregate
    {
        #region Fields

        /// <summary>
        /// The items.
        /// </summary>
        private readonly ArrayList _items = new ArrayList();

        #endregion

        #region Public Properties

        /// <summary>
        /// Gets the count.
        /// </summary>
        public int Count => _items.Count;

        #endregion

        #region Public Indexers

        /// <summary>
        /// Indexer.
        /// </summary>
        /// <param name="index">
        /// The index.
        /// </param>
        /// <returns>
        /// The <see cref="object"/>.
        /// </returns>
        public object this[int index]
        {
            get { return _items[index]; }

            set { _items.Insert(index, value); }
        }

        #endregion

        #region Public Methods and Operators

        /// <summary>
        /// Create iterator.
        /// </summary>
        /// <returns>
        /// The <see cref="Iterator"/>.
        /// </returns>
        public override Iterator CreateIterator()
        {
            return new ConcreteIterator(this);
        }

        #endregion
    }

    /// <summary>
    /// The 'Iterator' abstract class.
    /// </summary>
    internal abstract class Iterator
    {
        #region Public Methods and Operators

        /// <summary>
        /// The current item.
        /// </summary>
        /// <returns>
        /// The <see cref="object"/>.
        /// </returns>
        public abstract object CurrentItem();

        /// <summary>
        /// The first.
        /// </summary>
        /// <returns>
        /// The <see cref="object"/>.
        /// </returns>
        public abstract object First();

        /// <summary>
        /// The is done.
        /// </summary>
        /// <returns>
        /// The <see cref="bool"/>.
        /// </returns>
        public abstract bool IsDone();

        /// <summary>
        /// The next.
        /// </summary>
        /// <returns>
        /// The <see cref="object"/>.
        /// </returns>
        public abstract object Next();

        #endregion
    }

    /// <summary>
    /// The 'ConcreteIterator' class.
    /// </summary>
    internal class ConcreteIterator : Iterator
    {
        #region Fields

        /// <summary>
        /// The aggregate.
        /// </summary>
        private readonly ConcreteAggregate _aggregate;

        /// <summary>
        /// The current.
        /// </summary>
        private int _current;

        #endregion

        #region Constructors and Destructors

        /// <summary>
        /// Initializes a new instance of the <see cref="ConcreteIterator"/> class.
        /// </summary>
        /// <param name="aggregate">
        /// The aggregate.
        /// </param>
        public ConcreteIterator(ConcreteAggregate aggregate)
        {
            _aggregate = aggregate;
        }

        #endregion

        #region Public Methods and Operators

        /// <summary>
        /// The current item.
        /// </summary>
        /// <returns>
        /// The <see cref="object"/>.
        /// </returns>
        public override object CurrentItem()
        {
            return _aggregate[_current];
        }

        /// <summary>
        /// The first.
        /// </summary>
        /// <returns>
        /// The <see cref="object"/>.
        /// </returns>
        public override object First()
        {
            return _aggregate[0];
        }

        /// <summary>
        /// Gets whether iterations are complete.
        /// </summary>
        /// <returns>
        /// The <see cref="bool"/>.
        /// </returns>
        public override bool IsDone()
        {
            return _current >= _aggregate.Count;
        }

        /// <summary>
        /// The next.
        /// </summary>
        /// <returns>
        /// The <see cref="object"/>.
        /// </returns>
        public override object Next()
        {
            object ret = null;

            if (_current < _aggregate.Count - 1)
            {
                ret = _aggregate[++_current];
            }

            return ret;
        }

        #endregion
    }
}

// Output:
/*
Iterating over collection:
Item A
Item B
Item C
Item D

*/

This real-world code demonstrates the Iterator pattern which is used to iterate over a collection of items and skip a specific number of items each iteration.

/*
 * Real-World Iterator Design Pattern.
 */

namespace Iterator.RealWorld
{
    using System;
    using System.Collections;

    /// <summary>
    /// The 'Aggregate' interface.
    /// </summary>
    internal interface IAbstractCollection
    {
        #region Public Methods and Operators

        /// <summary>
        /// Create iterator.
        /// </summary>
        /// <returns>
        /// The <see cref="Iterator"/>.
        /// </returns>
        Iterator CreateIterator();

        #endregion
    }

    /// <summary>
    /// The 'Iterator' interface.
    /// </summary>
    internal interface IAbstractIterator
    {
        #region Public Properties

        /// <summary>
        /// Gets the current item.
        /// </summary>
        Item CurrentItem { get; }

        /// <summary>
        /// Gets a value indicating whether is done.
        /// </summary>
        bool IsDone { get; }

        #endregion

        #region Public Methods and Operators

        /// <summary>
        /// The first.
        /// </summary>
        /// <returns>
        /// The <see cref="Item"/>.
        /// </returns>
        Item First();

        /// <summary>
        /// The next.
        /// </summary>
        /// <returns>
        /// The <see cref="Item"/>.
        /// </returns>
        Item Next();

        #endregion
    }

    /// <summary>
    /// Startup class for Real-World Iterator Design Pattern.
    /// </summary>
    internal static class Program
    {
        #region Methods

        /// <summary>
        /// Entry point into console application.
        /// </summary>
        private static void Main()
        {
            // Build a collection
            var collection = new Collection
            {
                [0] = new Item("Item 0"),
                [1] = new Item("Item 1"),
                [2] = new Item("Item 2"),
                [3] = new Item("Item 3"),
                [4] = new Item("Item 4"),
                [5] = new Item("Item 5"),
                [6] = new Item("Item 6"),
                [7] = new Item("Item 7"),
                [8] = new Item("Item 8")
            };

            // Create iterator.
            var iterator = new Iterator(collection) {Step = 2};

            // Skip every other item.
            Console.WriteLine("Iterating over collection:");
            for (Item item = iterator.First(); !iterator.IsDone; item = iterator.Next())
            {
                Console.WriteLine(item.Name);
            }
        }

        #endregion
    }

    /// <summary>
    /// A collection item.
    /// </summary>
    internal class Item
    {
        #region Constructors and Destructors

        /// <summary>
        /// Initializes a new instance of the <see cref="Item"/> class.
        /// </summary>
        /// <param name="name">
        /// The name.
        /// </param>
        public Item(string name)
        {
            Name = name;
        }

        #endregion

        #region Public Properties

        /// <summary>
        /// Gets the name.
        /// </summary>
        public string Name { get; }

        #endregion
    }

    /// <summary>
    /// The 'ConcreteAggregate' class.
    /// </summary>
    internal class Collection : IAbstractCollection
    {
        #region Fields

        /// <summary>
        /// The items.
        /// </summary>
        private readonly ArrayList _items = new ArrayList();

        #endregion

        #region Public Properties

        /// <summary>
        /// Gets the count.
        /// </summary>
        public int Count => _items.Count;

        #endregion

        #region Public Indexers

        /// <summary>
        /// Indexer.
        /// </summary>
        /// <param name="index">
        /// The index.
        /// </param>
        /// <returns>
        /// The <see cref="object"/>.
        /// </returns>
        public object this[int index]
        {
            get { return _items[index]; }

            set { _items.Add(value); }
        }

        #endregion

        #region Public Methods and Operators

        /// <summary>
        /// Create iterator.
        /// </summary>
        /// <returns>
        /// The <see cref="Iterator"/>.
        /// </returns>
        public Iterator CreateIterator()
        {
            return new Iterator(this);
        }

        #endregion
    }

    /// <summary>
    /// The 'ConcreteIterator' class.
    /// </summary>
    internal class Iterator : IAbstractIterator
    {
        #region Fields

        /// <summary>
        /// The collection.
        /// </summary>
        private readonly Collection _collection;

        /// <summary>
        /// The current.
        /// </summary>
        private int _current;

        /// <summary>
        /// The step.
        /// </summary>
        private int _step = 1;

        #endregion

        #region Constructors and Destructors

        /// <summary>
        /// Initializes a new instance of the <see cref="Iterator"/> class.
        /// </summary>
        /// <param name="collection">
        /// The collection.
        /// </param>
        public Iterator(Collection collection)
        {
            _collection = collection;
        }

        #endregion

        #region Public Properties

        /// <summary>
        /// Gets the current item.
        /// </summary>
        public Item CurrentItem => _collection[_current] as Item;

        /// <summary>
        /// Gets a value indicating whether is done.
        /// </summary>
        public bool IsDone => _current >= _collection.Count;

        /// <summary>
        /// Gets or sets the step.
        /// </summary>
        public int Step
        {
            get { return _step; }

            set { _step = value; }
        }

        #endregion

        #region Public Methods and Operators

        /// <summary>
        /// The first.
        /// </summary>
        /// <returns>
        /// The <see cref="Item"/>.
        /// </returns>
        public Item First()
        {
            _current = 0;
            return _collection[_current] as Item;
        }

        /// <summary>
        /// The next.
        /// </summary>
        /// <returns>
        /// The <see cref="Item"/>.
        /// </returns>
        public Item Next()
        {
            _current += _step;
            if (!IsDone)
            {
                return _collection[_current] as Item;
            }

            return null;
        }

        #endregion
    }
}

// Output:
/*
Iterating over collection:
Item 0
Item 2
Item 4
Item 6
Item 8

*/

 

1.迭代器适配器reverse_iterator

template <class _Iterator>

class reverse_iterator 

{

protected:

  _Iterator current;  //对应之正向迭代器
public:
  //逆向迭代器的5种associated types都和其相对应

  typedef typename iterator_traits<_Iterator>::iterator_category

          iterator_category;

  typedef typename iterator_traits<_Iterator>::value_type

          value_type;

  typedef typename iterator_traits<_Iterator>::difference_type

          difference_type;

  typedef typename iterator_traits<_Iterator>::pointer

          pointer;

  typedef typename iterator_traits<_Iterator>::reference

          reference;


  typedef _Iterator iterator_type;  
//代表正向迭代器

  typedef reverse_iterator<_Iterator> _Self;  
//代表逆向迭代器


public:

  reverse_iterator() {}

  explicit reverse_iterator(iterator_type __x) : current(__x) {}


  reverse_iterator(const _Self& __x) : current(__x.current) {}

#ifdef __STL_MEMBER_TEMPLATES

  template <class _Iter>

  reverse_iterator(const reverse_iterator<_Iter>& __x)

    : current(__x.base()) {}

#endif /* __STL_MEMBER_TEMPLATES */

  iterator_type base() const { return 
current; }  //取出对应的正向迭代器
  //对逆向迭代器取值，就是将对应之正向迭代器退一位取值

  reference operator*() const {

    _Iterator __tmp = current;

    return *--__tmp;

  }

#ifndef __SGI_STL_NO_ARROW_OPERATOR

  pointer operator->() const { return &(operator*()); }
#endif /* __SGI_STL_NO_ARROW_OPERATOR */
  //前进变后退，后退变成前进

  _Self& operator++() {

    --current;

    return *this;

  }

  _Self operator++(int) {

    _Self __tmp = *this;

    --current;

    return __tmp;

  }

  _Self& operator--() {

    ++current;

    return *this;

  }

  _Self operator--(int) {

    _Self __tmp = *this;

    ++current;

    return __tmp;

  }


  _Self operator+(difference_type __n) const {

    return _Self(current - __n);

  }

  _Self& operator+=(difference_type __n) {

    current -= __n;

    return *this;

  }

  _Self operator-(difference_type __n) const {

    return _Self(current + __n);

  }

  _Self& operator-=(difference_type __n) {

    current += __n;

    return *this;

  }

  reference operator[](difference_type __n) const { return *(*this + __n); }  

}; 
2.rbegin，rend
  reverse_iterator 
rbegin() { return reverse_iterator(end()); }

  reverse_iterator 
rend() { return reverse_iterator(begin()); }