Mi profesor me ha pedido que agregue un objeto en medio de un ArrayedList<Employee> usando listiterator.
Primero he intentado hacerlo de la siguiente manera:
ListIterator < Employee > li = emps.listIterator(emps.size()); System.out.println("\nUsing ListIterator:\n"); i = 1; while (li.hasPrevious()) { if (li.nextIndex() == 5) { li.add(emp_M); } System.out.println(" Employee " + (i++) + " " + li.previous()); } Pero esto produce un número aparentemente infinito de iteraciones en las que li.nextIndex() se atasca en 5. He verificado esto con el depurador y esto sucede solo después de que se li.add(emp_M) .
Encontré una solución donde agregué un break justo después de li.add(emp_M) y continué analizando la lista por separado de la misma manera pero sin agregar a la lista emp_M en absoluto:
//parse in two loops to add the middle employee, without the break the list seemingly spirals into infinity! System.out.println("\nUsing ListIterator:\n"); i = 1; while (li.hasPrevious()) { if (li.nextIndex() == 5) { li.add(emp_M); System.out.println("ADDED IN MIDDLE"); break; } System.out.println(" Employee " + (i++) + " " + li.previous()); } while (li.hasPrevious()) { System.out.println(" Employee " + (i++) + " " + li.previous()); } Esto me dejó preguntándome, ¿lo que hice fue un enfoque perezoso e ingenuo? ¿De qué otra manera puedo agregar a una lista con listIterator ?
Lo encontré después de profundizar en el depurador.
En el momento antes de agregar li.nextIndex() == 5 y li.previousIndex() == 4 Después de agregar el objeto, el cambio mencionado anteriormente a li.nextIndex() == 6 y li.previousIndex() == 5 esto se debe a que .add .add() de listIterator inserta el objeto antes .next() .
Avanzar con este problema establece un bucle de ida y vuelta donde li.previous() disminuye tanto li.previousIndex() como li.nextIndex() en 1, y llamar a li.add(emp_M) aumenta ambos valores mencionados anteriormente en 1.
Para solucionarlo, debemos omitir el elemento agregado después de agregar:
System.out.println("\nUsing ListIterator:\n"); i = 1; while (li.hasPrevious()) { if(li.nextIndex() == 5) { li.add(emp_M); li.previous(); System.out.println("ADDED IN MIDDLE"); // break; } System.out.println(" Employee " + (i++) + " " + li.previous()); }esto niega efectivamente el problema mencionado anteriormente.
¡A veces, simplemente haciendo una pregunta, encuentras la respuesta tú mismo!
Me voy a demorar en aceptar mi propia respuesta si alguien me la puede explicar mejor de lo que yo la entendí.
El problema en su código es que agregará el elemento emp_M indefinidamente.
Si pasamos por una iteración en la que agrega un elemento:
Supongamos li.nextIndex() == 5 , luego agregará un nuevo elemento a su iterador y, de acuerdo con la documentación de add , también aumentará en uno su índice (por lo tanto, mueve su iterador a la derecha). Luego, sus bucles continúan y mueve su iterador hacia la izquierda con li.previous() , que sucede antes de agregar el elemento (y verifica la condición if para agregar).
Ahora, comienza una nueva iteración de su ciclo while, verifica la condición nuevamente, agrega un nuevo elemento, etc. Permanecerá atascado en el elemento que verifica la condición agregando indefinidamente nuevos elementos.
Para facilitar el código, intente ejecutar su iterador en la dirección de la documentación (es decir e1 -> e2 -> e3 -> e4 )
ListIterator < Employee > li = emps.listIterator(); i = 1; while (li.hasNext()) { if (li.nextIndex() == 5) { li.add(emp_M); } System.out.println(" Employee " + (i++) + " " + li.next()); }