The answer is this: There are different implementations of interface List, for example ArrayList and LinkedList. The main difference between these implementations is that for one, some operations are efficient and other operations are less efficient and vice versa.
For example, random lookup (using get(...)) is efficient on an ArrayList, but not on a LinkedList (because it has to walk through the whole list to get at the element you are looking for). So the second loop (using "size()") is very inefficient when the List is a LinkedList.
Using an iterator is better, because the iterator that you get from the list "knows" what the most efficient way is for looping through the list. (The list itself supplies the iterator, so it can give you an iterator that is efficient for that particular implementation of List).
Also, by using an iterator, you are using the same interface for every kind of list. I can always use the same code, no matter what kind of implementation the unerlying list has.
there are cases where i don't care what the underlying implementation is - i just want a list. i want to be able to loop over it.
if i do it your way, i am locking myself into a specific algorithm. if the list changes how it's designed, or somebody come up with a brand new kind of list, you might be out of luck until you can re-factor your code to handle the changes.
using an iterator, i have a common way to go through ANY kind of list, as long as that list supports the iterator interface. maybe we have 12 different lists we need to iterate through, one an array list, one a map, one a set... i can write
you would have to write:
my code lets anybody add any new kind of list any time they want, or change the underlying implementation of an existing list, and i don't care. my code doesn't break.
yours can't handle a new type of list without you changing your code. and if somebody changes how an existing list works, you might be out of luck again.
There are only two hard things in computer science: cache invalidation, naming things, and off-by-one errors