EJERCICIO ENTREGA CU00678B dejar Iterator sin especificar tipo java

[betico]

Buenas tardes.

Estoy "atascado" con el ejercicio de la entrega CU00678B del curso de Java desde cero. Mi problema es que no sé como puedo recorrer el contenido de los elementos de una lista, siendo dichos elementos a su vez listas de objetos de distinto tipo. He escrito lo siguiente:

            ArrayList<Set> listaObjetos;
       
        HashSet<String> objetosHash;
        objetosHash = new HashSet<String>();
        objetosHash.add("sol");
        objetosHash.add("luna");
        objetosHash.add("saturno");

        TreeSet<Integer> objetosTree;
        objetosTree = new TreeSet<Integer>();
        objetosTree.add(2);
        objetosTree.add( 8) ;
        objetosTree.add(5);       
       
        listaObjetos = new ArrayList<Set>();
        listaObjetos.add(objetosHash);
        listaObjetos.add(objetosTree);
       
        Iterator<Set> it = listaObjetos.iterator();
        while(it.hasNext())
        {
            Set objetoSet = it.next();

        }

pero ya no sé continuar. No sé como recorrer los elementos del objeto objetoSet ya que la primera vez serán objetos String y la segunda Integer.

Un saludo y muchas gracias.

[betico]

Buenas de nuevo.

He probado a incluir la siguiente sentencia dentro del while y he conseguido que se muestren los valores:

          System.out.print(objetoSet);

Lo que no estoy seguro es de si era eso lo que se pretendía ya que lo que yo había entendido es que tanto la lista principal como las internas debían recorrerse con iterator.

Un saludo.

[César Krall]

Hola, lo primero, cuando vayas a pegar código usa el icono # que aparece en el editor por favor. Pulsas el # y te aparecen las etiquetas [ code ] ... [ / code] y pegas el código entre estas dos etiquetas.

Sobre el ejercicio: has llegado a "prácticamente" la solución. Como dices, la idea es recorrer cada uno de los elementos, no simplemente hacer un print que muestre todos los elementos en su conjunto.

Te doy la idea para que intentes resolverlo por tí mismo, si ves que se te complica mira el código que te pongo más abajo.

La idea: estás haciendo un recorrido del ArrayList gracias a un iterator que recorre sus elementos. Pero a su vez cada elemento del ArrayList consta de elementos. ¿Cómo recorrerlos? Introduciendo un nuevo iterador, es decir, tendrías un iterador que te va recorriendo los elementos del arraylist y tendrías otro iterador que te va recorriendo cada uno de los elementos dentro del arrayList. Estás anidando un recorrido dentro de otro. A cada iterador le debes poner un nombre distinto, por ejemplo it1 e it2.

Código:

Código: [Seleccionar]

import java.util.HashSet;
import java.util.ArrayList;
import java.util.TreeSet;
import java.util.Set;
import java.util.Iterator;

public class testCU00678B {
    public testCU00678B()    {    }
    public static void main (String[] Args) {
        System.out.println ("Comienza el programa");
        ArrayList<Set> listaObjetos;
        HashSet<String> objetosHash;
        objetosHash = new HashSet<String>();
        objetosHash.add("sol");
        objetosHash.add("luna");
        objetosHash.add("saturno");
        TreeSet<Integer> objetosTree;
        objetosTree = new TreeSet<Integer>();
        objetosTree.add(2);
        objetosTree.add( 8) ;
        objetosTree.add(5);
        listaObjetos = new ArrayList<Set>();
        listaObjetos.add(objetosHash);
        listaObjetos.add(objetosTree);
        Iterator<Set> it1 = listaObjetos.iterator();
        while(it1.hasNext())
        {
            Set objetoSet = it1.next();
            System.out.print ("Conjunto set contiene: " );

            Iterator<Set> it2 = objetoSet.iterator();
            while (it2.hasNext()){
                System.out.print ("Elemento: " + it2.next() +", ");
            }
            System.out.println("");
        }

    }
}
Saludos.

[betico]

Ok, gracias por tu respuesta y perdona por lo del código. Soy nuevo por aquí y no lo sabia.

En cuanto a la solución que me comentas, esa orientación era la que yo quería conseguir, pero me parecía que el código no era correcto. Me intento explicar.

Yo lo que he entendido sobre iterator es que lo que hacemos es crear una lista copia de la original para poder recorrerla. Pero para ello, en la sentencia debemos especificar el tipo de los elementos contenidos en la lista. En este caso los elementos de it1 son de tipo Set (implementan esa interface) y por lo tanto entiendo la sentencia:

Código: [Seleccionar]

Iterator<Set> it1 = listaObjetos.iterator();
Pero cuando pasamos al siguiente nivel, los objetos listas que estamos tratando tienen objetos de distintos tipos (una lista tiene String y la otra Integer). Por lo tanto, yo creía que el iterator que debíamos crear en ese segundo nivel debería contemplar eso. Pero no veía cómo podía especificar un tipo que pudiese abarcar esos dos.  Para cada uno de ellos por separado, la sentencia sería:

Código: [Seleccionar]

Iterator<String> it2 = listaObjetos.iterator();
o

Código: [Seleccionar]

Iterator<Integer> it2 = listaObjetos.iterator();
Por eso no acabo de entender (a pesar que he comprobado que funciona correctamente) la sentencia:

Código: [Seleccionar]

Iterator<Set> it2 = objetoSet.iterator();
it2 sí es un objeto Set, pero sus elementos no (serán String o Integer, en este caso).

No es fácil de explicar por correo y no sé si te habrá quedado claro cuál es mi duda.

Un saludo y gracias de nuevo.

[César Krall]

Creo que tienes razón. En principio se puede dejar sin especificar el tipo a recorrer y dejar que el compilador lo determine por sí solo. Es decir, escribir:

Código: [Seleccionar]

            Iterator it2 = objetoSet.iterator();
            while (it2.hasNext()){
                System.out.print ("Elemento: " + it2.next() +", ");
            }
De esta manera no se especifica el tipo a recorrer y se obtiene un iterador para el tipo de elementos que contiene la colección (sean String, Integer u otro). Además se evita que salte un warning que saltaba antes.

Es decir, en la primera pasada del bucle externo it2 será un iterador sobre String y en la segunda pasada será un iterador sobre Integer. En este caso it2 se "reconstruye" con cada pasada del bucle exterior y por tanto se redefine el tipo implicado en el recorrido en el bucle interior.

[betico]

Ok. Aclarado. Muchas gracias.