Does the Internal Iterator use the hasNext() and next() to iterate in Java?

I'm learning about internal iterators and I understand that an internal iterator manage the iterations in the background:

   public void internalIterator(){
      List<String> namesList = Arrays.asList("Tom", "Dick", "Harry");
      namesList.forEach(name -> System.out.println(name));
   }

But I think that enhanced for loop does the same thing:

 public void enhancedForLoop(){
  List<String> namesList = Arrays.asList("Tom", "Dick", "Harry");
  for(String name : namesList){
    System.out.println(name);
  }
 }

I know that enhanced for loop uses hasNext() and next() methods in the background. And enhanced for loop is an external iterator. Then why forEach() method is an internal iterator? Doesn't forEach() method use hasNext() and next() methods in the background? How the iterations are managed in the backgorund in a different way than enhanced for loop? And is the iteration faster using forEach() than using enhanced for loop? Any feedback will be apreciated?

See also the definition of forEach on the interface Iterable.
Both constructs use different methods of the same interface.

Conceptually, the difference is that in an "enhanced for loop" the class implementing the Iterable only creates the Iterator, and the loop construct is responsible for advancing it (see also this related question).

When calling forEach, the class controls the entire process of iteration, and can pick whatever is most suitable for its underlying data structure. For example, it could avoid creating an Iterator object, and instead use some internal array index or similar.

Other than that, they should be equivalent. In most cases I wouldn't expect any difference in performance.

See this excellent answer for some additional reasons why you might want to use forEach, e.g. additional consistency guarantees when iterating synchronized collections, and this one mentioning things that it does not provide, such as flow control (e.g. short-circuiting using break) or support for checked exceptions.

The difference is what the user of the API has to do.

Differences

External

When using iterator(), it's the user's job (your job) to manage the traversal: when to call hasNext() and when to call next(). The iteration is handled externally from the API, by the user of the API. The user both iterates through the elements & consumes the elements.

Internal

When using forEach, it's the API's job to manage the traversal. The iteration is handled internally instead of by the user; the user only consumes the elements.

Conclusion

It doesn't matter if hasNext() and next() are being called. What does matter is who calls hasNext() and next() - who handles the iteration, who is in charge of the iterator.

forEach is internal because the user doesn't have control over how the elements are iterated through. The API handles it; the iterator is internal.

iterator() is external because the user must define how iteration will occur. The API passes you the iterator, and that's all the API does. The iterator is external.

Even though forEach uses iterator() in some cases, that iterator is still internal to the API you're using (the List). Whoever calls forEach still only worry about consuming elements. The user doesn't control how the elements are traversed through, so it doesn't matter what forEach uses.

Suggestions on when to use a strategy

You'd use an enhanced loop when you need the most basic of sequential iteration.

You'd use an iterator() when you need more complex iteration.

You'd use forEach when you're only worried about consuming the elements, and don't mind if the API decides on how to traverse through the collection.

I don't know where you got that "enhanced for loop is an external iterator", but Iterable.forEach just does the same thing as your second example (could be overridden, though I don't see any reason to).

default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        action.accept(t);
    }
}