Iterator hasNext for the last record fetching

private static void printList(LinkedList<String> linkedList) 
{
        Iterator<String> i = linkedList.iterator();

        while(i.hasNext()) 
        {
            System.out.println(i.next());
        }

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

As per my understanding, i.hasNext() method checks whether the next entry exists or not and returns true or false.

And the i.next() method above here, will display the current linkedList record and then increments/moves to the next record.

If we are in the last record, i.hasNext() is false, how is it still executing the last iteration of i.next()?

So say you have your list as 1, 2, 3, 4

Your iterator hasNext() will return true when it will start since it's currently pointing to the start and next has 1 in it. With i.next(), you will get 1.

Now, in second to last iteration, when the cursor is at 3 and you have received 3 with i.next(). Now i.hasNext() will return true since it has 4 and you will be inside the loop, doing i.next() that consumes the whole list so next invocation of i.hasNext() will return false, terminating the loop.

I highly recommend you check out how the next and hasNext methods are implemented in the OpenJDK: Link.

The linked list iterator has an nextIndex variable that points to the index of the item that should be returned if you call next. Calling next, as you has identified, will increment this variable.

Let's say you have the list [0, 1, 2, 3, 4], and you are about to call next() for the third time. After that, the state of the iterator looks like:

            nextIndex is pointing to this
               |
               V
0    1    2    3    4
          ^
          |
        return value of the third next()

I think you have this confusion because you don't understand what hasNext is doing. hasNext does not check whether whether the index after nextIndex is a valid index. It checks whether nextIndex is a valid index. This is how hasNext is implemented:

return nextIndex < size;

As long as hasNext is pointing to an item in the list, that is true.

Now let's see what happens in the next iteration of the loop:

                 nextIndex is pointing to this
                    |
                    V
0    1    2    3    4
               ^
               |
             return value of the fourth next()

nextIndex is 4 (not to be confused with the element that it points to), which is less than size (5), so hasNext is still true, so you the loop gets to run one more time:

                      nextIndex is pointing to this
                         |
                         V
0    1    2    3    4
                    ^
                    |
                  return value of the fifth next()

Now nextIndex is greater than size, pointing to something outside of the linked list, so hasNext is false, and the loop stops. next has returned all 5 elements.

e.g., list as 1, 2, 3, 4

See the java.util.LinkedList.ListItr.java

public boolean hasNext() {
  return nextIndex < size;
}

nextIndex = 0, size = 4, hence hasNext = true, then if you you call next() then it returns item from position 0 that is = 1 and increment nextIndex + 1

nextIndex = 1, size = 4, hence hasNext = true, then if you you call next() then it returns item from position 1 that is = 2 and increment nextIndex + 1

nextIndex = 2, size = 4, hence hasNext = true, then if you you call next() then it returns item from position 2 that is = 3 and increment nextIndex + 1

nextIndex = 3, size = 4, hence hasNext = true, then if you you call next() then it returns item from position 3 that is = 4 and increment nextIndex + 1

nextIndex = 4, size = 4, hence hasNext = FALSE

Iterator is a Interface. Here is code how hasNext() and next() method works.

// Java code to illustrate the use of iterator 
import java.io.*; 
import java.util.*; 

class Test { 
	public static void main(String[] args) 
	{ 
		ArrayList<String> list = new ArrayList<String>(); 

		list.add("A"); 
		list.add("B"); 
		list.add("C"); 
		list.add("D"); 
		list.add("E"); 

		// Iterator to traverse the list 
		Iterator iterator = list.iterator(); 

		System.out.println("List elements : "); 

		while (iterator.hasNext()) 
        {
          
		  System.out.print(iterator.hasNext()+" "+iterator.next() + " "+iterator.hasNext()+"\n"); 
        }
		System.out.println(); 
	} 
} 

output of above code:
List elements :
true A true
true B true
true C true
true D true
true E false

Defination of hasNext() and next() methods:

public class NextFromIterator implements Iterator<String> {
    private int position = -1;
    private List<String> list = new ArrayList<String>() {{
        add("alpha"); add("bravo"); add("charlie"); add("delta"); add("echo"); add("foxtrot");
    }};
     
    public boolean hasNext() {
        return next() != null;  // BAD: Call to 'next'
    }
     
    public String next() {
        position++;
        return position < list.size() ? list.get(position) : null;
    }
 
    public void remove() {
        // ...
    }
     
    public static void main(String[] args) {
        NextFromIterator x = new NextFromIterator();
        while(x.hasNext()) {
            System.out.println(x.next());
        }
    }

Every Iteration next() increment the its pointer by 1 initial it is point to -1. After that pointer is checked with actual size of iterator if it is less than that then this method returns that element otherwise it returns null. In hasNext() method this next() method called for every loop and here it is checked that weather it is equal to null or not.