Iterator in Java

冷不防 2023-09-24 18:39 39阅读 0赞

# 1.Introduce #

*  Java Iterator is `an interface` that is practiced in order to iterate over a collection of Java object components entirety one by one.
 *  It is free to use in the Java programming language since the Java 1.2 Collection framework. It belongs to `java.util package`.
 *  `Java Iterator interface`succeeds the`enumerator iterator` that was practiced in the beginning to traverse over some accessible collections like the `ArrayLists`.

# 2.Advantages of Java Iterator #

*  The user can apply these iterators to any of the classes of the `Collection framework`.
 *  In Java Iterator, we can use both of the `read and remove operations`.
 *  If a user is working with a for loop, they cannot  
    modernize(add/remove) the Collection, whereas, if they use the Java Iterator, they can `simply update the Collection`.

# 3.Disadvantages of Java Iterator #

*  The Java Iterator `only preserves the iteration in the forward direction`. In simple words, the Java Iterator is `a uni-directional Iterator`.
 *  The replacement and extension of **a new component are not approved** by the Java Iterator.
 *  In CRUD Operations, the Java Iterator **does not hold the various operations like CREATE and UPDATE.**

# 4.Java Iterator Methods #

1.  hasNext(): Returns true if the iteration has more elements.  
    `public boolean hasNext();`
2.  next(): Returns the next element in the iteration. It throws `NoSuchElementException` if no more element is present.  
    `public Object next();`
3.  remove(): Removes the next element in the iteration. This method can be called only once per call to next().  
    `public void remove();`  
    **Note:** remove() method can`throw two exceptions` namely as follows:

`UnsupportedOperationException` : If the remove operation is not supported by this iterator  
`IllegalStateException` : If the next method has not yet been called, or the remove method has already been called after the last call to the next method.

# 5.Code #

// Java program to Demonstrate Iterator
     
    // Importing ArrayList and Iterator classes
    // from java.util package
    import java.util.ArrayList;
    import java.util.Iterator;
     
    // Main class
    public class Test {
        
        // Main driver method
        public static void main(String[] args)
        {
        
            // Creating an ArrayList class object
            // Declaring object of integer type
            ArrayList<Integer> al = new ArrayList<Integer>();
     
            // Iterating over the List
            for (int i = 0; i < 10; i++)
                al.add(i);
     
            // Printing the elements in the List
            System.out.println(al);
     
            // At the beginning itr(cursor) will point to
            // index just before the first element in al
            Iterator<Integer> itr = al.iterator();
     
            // Checking the next element  where
            // condition holds true till there is single element
            // in the List using hasnext() method
            while (itr.hasNext()) {
        
                //  Moving cursor to next element
                int i = itr.next();
     
                // Getting elements one by one
                System.out.print(i + " ");
     
                // Removing odd elements
                if (i % 2 != 0)
                    itr.remove();
            }
     
            // Command for next line
            System.out.println();
     
            // Printing the elements inside the object
            System.out.println(al);
        }
    }

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    0 1 2 3 4 5 6 7 8 9 
    [0, 2, 4, 6, 8]