The type of for that you use is (if I don't remember) the most basic there is and the first one, which reads as follows:

//  i = 0  -> Indicas el valor inicial de la variable que iterará el array
//  i < listaObjeto.size() -> Indicas la condición con la cual dejará de iterar el array cuando se cumpla, en este caso cuando "i" sea menor que el tamaño de tu array.
//  i ++   -> El crecimiento del valor de la variable, en este caso se le suma +1 con cada iteración.
for (i = 0 ; i < listaObjeto.size() ; i++){
    //  Tu código.
    Objeto o = listaObjetos.get(i);
}

An inconvenience with this for is that, if you do not define the condition with which to iterate well, you may not go through the array completely or you may get an Exception due to an index outside the array.

Instead of it, to loop through objects I recommend you use this form of for:

//  Objeto o    -> Variable instanciada del tipo de tu objeto, y que tomará el valor de cada uno dentro del array.
//  objetoLista -> Array de Objeto a iterar.
for(Objeto o : obejtoLista){
    //  Tu código
}

By having the variable o of type Object it will iterate all the objects inside the array. I hope my answer has helped and served you. Greetings.

for (ListIterator it = pila1.listIterator(pila1.size()); it.hasPrevious();) {
    for (ListIterator itt = pila2.listIterator(pila2.size()); itt.hasPrevious();) {

        int n1 = (Integer) it.previous();
        int n2 = (Integer) itt.previous();

        int n3 = (n1 + n2 + uno);

        if (n3 >= 10) {
            cola.add(n3 - 10);
            uno = 1;

        } else {
            cola.add(n3 + uno);
        }
        it.remove();  <--
        itt.remove();  <--
    }

• In the first iteration, you start with two lists of 5 elements.

• You enter the forouter, you get an iterator at the end ¹ of the first list, as hasPreviousis trueyou enter the loop.

• You go into the forinternet, you get an iterator at the end ¹ of the second list, as hasPreviousit is trueyou go into the loop.

• On each iteration of the inner loop, you get the previous element from both lists, and remove that element from each list . That is, in the first iteration of the outer loop you are going to do 5 iterations of both lists and remove 5 elements from both lists , leaving both lists empty and the two iterators at the beginning of their respective lists.

  From that point on, both it.hasPrevious()return itt.hasPrevious()false so both are exited for.

As for the solution, it is not clear what the code has to do so there can be no answer, but what is clear is that in the current code one of them is forleft over.

You should explain what your code should do

Anyway, it seems to me that your code receives two numbers, stores them in two lists and then adds them digit by digit.

Loop Behavior

The problem you have is that you do n't need two loops .

If you want to add two lists element by element, you have to do a number of loops exactly equal to the size of the larger list , which is solved by iterating through that list. What you want to do is iterate through both lists, but do it a number of times equal to the size of the other list. That is, You have many cycles left over .

In mathematical terms, we can say that yes n = m = lista2.size();, you want to do n * mloops when really you just need nloops.

I've taken the liberty of modifying your code. The code inside the loops looks like this:

public static void sumarListas(List<Integer> pila1, List<Integer> pila2, List<Integer> cola) {        
    int uno = 0;
    int n1;
    int n2;
    int n3;
    
    //Dos Iterators, pero solo un bucle
    ListIterator<Integer> it = pila1.listIterator(pila1.size());
    for (ListIterator<Integer> itt = pila2.listIterator(pila2.size()); itt.hasPrevious();) {

        n1 = it.previous();
        n2 = itt.previous();
        n3 = (n1 + n2 + uno);

        if (n3 >= 10) {
            cola.add(n3 - 10);
            uno = 1;

        } else {  //Si no es mayor que diez, uno tiene que ser 0
            cola.add(n3);  //No tenía sentido sumarle uno más solo por ser mayor de diez
            uno = 0;
        }
    }

    if (uno == 1) {
        cola.add(1);
    }

}

You will notice that I have modified your else, I think this is the behavior it should have.

code improvement

As for code improvement, I can give you a couple of rules of thumb that will improve how well your code can be read, tested, and modified.

• Give your variables meaningful names . It is much easier to understand a code whose variables explain what they are just by reading their name.
• Separate as much logic as possible into methods If you have all your logic in the method main, it's hard to read and test. If you separate it into small methods that deal with a single thing and, in addition, name those methods in an appropriate way (Explaining what they do) you will be able to better understand what happens in your code.
• Generally, use the simplest solution A simple solution makes the code easier to read than a complex solution.

Referring to your code specifically, I can tell you:

• The static method Character.getNumericValue()is easier to read than digito - '0'. It also protects you against non-Unicode numbers.
• As of Java 7, you do not have to specify the generic type on instantiation. That is to say: List<Integer> pila1 = new ArrayList<Integer>();it is the same asList<Integer> pila1 = new ArrayList<>();
• Create two Iteratorseems too much to me to iterate a list and operate two. I think a fornormal loop would have served you better.
• Removing already iterated items from the list doesn't do you any good, other than consuming more processor time. If you don't need to remove them, don't.
• As of Java 8, list operations have been greatly simplified. Query Streams, Lambda Expressions , the Interface, Iterableand Method References .

I have rewritten your code following the criteria I have listed:

public static void main(String[] args) {
    Scanner leer = new Scanner(System.in);

    List<Integer> numeroASumar1 = new ArrayList<>();
    List<Integer> numeroASumar2 = new ArrayList<>();
    List<Integer> resultado = new ArrayList<>();

    recogerListas(leer, numeroASumar1, numeroASumar2);

    sumarListas(numeroASumar1, numeroASumar2, resultado);

    System.out.println("La suma de las pilas es:");        
    escribirLista(resultado);
}

public static void recogerListas(Scanner leer, List<Integer> listaALlenar1, List<Integer> listaALlenar2)
{
    //A mi me gusta separar los métodos lo mas posible y hubiera separado
    //la lectura de la línea y la asignacion a las listas, pero me parecia
    //demasiado para este ejemplo
    System.out.println("Introduzca los digitos (5) para la pila1");        
    for (char digito : leer.nextLine().toCharArray()) {
        listaALlenar1.add(digito - '0');
    }

    System.out.println("Introduzca los digitos (5) para la pila2");
    for (char digito : leer.nextLine().toCharArray()) {
        listaALlenar2.add(digito - '0');
    }
}

public static void escribirLista(List<Integer> lista)
{
    //Utiliza java 8 
    lista.forEach(System.out::println);
}

public static void sumarListas(List<Integer> numeroASumar1, List<Integer> numeroASumar2, List<Integer> resultado) {
    int acarreo = 0;
    int suma;
    
    //bucle for invertido
    for (int i = numeroASumar1.size() - 1; i >= 0; i--) {
        suma = numeroASumar1.get(i) + numeroASumar2.get(i) + acarreo;
        if (suma >= 10) {
            suma -= 10;
            acarreo = 1;
        } else {
            acarreo = 0;
        }
        resultado.add(suma);            
    }
    if (acarreo == 1) resultado.add(acarreo);
}

Incidentally, adding the lists could probably have been fixed in a line or two of code with Streams and its map()and methods filter(). I'll try to do it later if required.