Iterator and iterable differences and linkages

Ext.: http://blog.csdn.net/zq602316498/article/details/39337899

traversing a collection with iterator mode

The iterator pattern is the standard access method used to traverse the collection class. It abstracts the access logic from different types of collection classes, thus avoiding exposing the internal structure of the collection to the client.

For example, if you are not using iterator, the way to traverse an array is to use the index: for (int i=0; i<array.size (); i++) {...} ...}

While accessing a linked list (LinkedList) must also use the while loop: while ((E=e.next ())!=null) {...} e.data () ...}

Both methods the client must know in advance the internal structure of the collection, the Access code and the collection itself is tightly coupled , unable to separate the access logic from the collection class and client code, each collection corresponding to a traversal method, the client code can not be reused.

Even more frightening, if you later need to change ArrayList to LinkedList, the original client code must all be rewritten.

To solve the above problem, the Iterator pattern always uses the same logic to traverse the collection: for (Iterator it = C.iterater (); It.hasnext ();) { ... }

The secret is that the client itself does not maintain a "pointer" that iterates through the collection, and that all internal states (such as the current element's position and whether there is a next element) are maintained by iterator , and this iterator is generated by a factory method of the collection class, so it knows how to traverse the entire collection.

The client never deals directly with the collection class, it always controls the iterator, sends a "forward", "backward", "Fetch current" command to it, and can traverse the entire collection indirectly.

First look at the definition of the Java.util.Iterator interface:
Public interface Iterator {Boolean hasnext (); Object next (); void Remove (); }

Depending on the first two methods you can complete the traversal, the typical code is as follows:
for (Iterator it = C.iterator (); It.hasnext ();) {Object o = It.next ();//operation on o ...}

Each collection class may return a different iterator specific type, and the array may return Arrayiterator,set may return Setiterator,tree may return treeiterator, but they all implement the iterator interface, so , the client doesn't care what kind of Iterator it is, it just needs to get the Iterator interface, which is the power of object-oriented.

All collection classes implement the Collection interface, while Collection inherits the Iterable interface.

[Java]View PlainCopy 

2. /**
4. * Implementing this interface allows a object to be the target of
6. * the "foreach" statement.
8. *
10. * @param <T> The type of elements returned by the iterator
12. *
14. * @since 1.5
16. */
18. Public interface Iterable<t> {
22. /** 
24. * Returns an iterator over a set of elements of type T.
26. *
28. * @return an Iterator.
30. */
32. Iterator<t> Iterator ();
34. }

In a specific implementation class (such as ArrayList), a Itr inner class is maintained internally, which inherits the Iterator interface, and its hasnext () and Next () methods are coupled to the ArrayList implementation. When the iterator () method of the ArrayList object is called, an instance of the class Itr is returned, enabling the ability to traverse ArrayList.

[Java]View PlainCopy  

2. Public iterator<e> Iterator () {
4. return new Itr ();
6. }
10. /** 
12. * An optimized version of ABSTRACTLIST.ITR
14. */
16. private class Itr implements iterator<e> {
18. int cursor; //Index of next element to return
20. int lastret =-1; //Index of last element returned;-1 if no such
22. int expectedmodcount = Modcount;
26. Public Boolean hasnext () {
28. return cursor! = size;
30. }
34. @SuppressWarnings ("unchecked")
36. Public E Next () {
38. Checkforcomodification ();
40. int i = cursor;
42. if (i >= size)
44. throw new Nosuchelementexception ();
46. object[] Elementdata = ArrayList.  This.elementdata;
48. if (i >= elementdata.length)
50. throw new Concurrentmodificationexception ();
52. cursor = i + 1;
54. return (E) Elementdata[lastret = i];
56. }
60. public Void Remove () {
62. if (Lastret < 0)
64. throw new IllegalStateException ();
66. Checkforcomodification ();
70. try {
72. ArrayList.  This.remove (Lastret);
74. cursor = Lastret;
76. Lastret =-1;
78. Expectedmodcount = Modcount;
80. } catch (Indexoutofboundsexception ex) {
82. throw new Concurrentmodificationexception ();
84. }
86. }
90. final void Checkforcomodification () {
92. if (modcount! = expectedmodcount)
94. throw new Concurrentmodificationexception ();
96. }
98. }

Why do you have to implement iterable this interface? Why not implement the iterator interface directly?

Look at the collection classes in the JDK, such as the list family or set family, are implemented Iterable interface, but do not directly implement the iterator interface. It makes sense to think carefully about it.

Because the core method of the Iterator interface next () or Hasnext () is dependent on the current iteration position of the iterator. If collection implements the iterator interface directly, it is bound to cause the collection object to contain the data (pointers) of the current iteration position. When a collection is passed between different methods, the result of the next () method becomes unpredictable because the current iteration position is not pre-provisioned. Unless you add a reset () method to the iterator interface, you can reset the current iteration position. But in this case, collection can only have one current iteration position at a time . Instead, iterable returns an iterator (a new iterator ) that counts from the beginning of each call . multiple iterators are non-interfering .

Iterator and iterable differences and linkages