Ejercicio CU00677B y CU00678B interface Iterable java

[toni_apr]

Preguntas y respuestas CU00677B

Busca información en la documentación oficial de Java sobre la interface Iterable. ¿Qué clases de las
que conoces implementan esta interface? ¿Qué método han de tener disponible las clases que
implementan esta interface? ¿Para qué sirve este método?

Respuesta:
La interface Iterable está implementada en las clases:
ArrayList (usada en los ejemplos prácticos)
LinkedList y Stack (otras clases para manipular colecciones)
entre otras muchas.

Estas clases han de disponer del método 'iterator()' (Al parecer, el único método en esta interface)
El método iterator() como se dice en la documentación del interface Iterable, es permitir que un objeto sea el destino en un for extendido
-------------------------
Ejercicio CU00678B
Clase EjercicioPolimorfismo

Código: [Seleccionar]

import java.util.*;

/**
 * Detalles de la clase.
 * @author (Toni)
 * @version (0)
 */
public class EjercicioPolimorfismo {           
    public static void main (String [] args) {
        // Declaración del ArrayList
        ArrayList<Set> planetasYCifras = new ArrayList<Set>();
        String [] planetasArr = {"sol", "luna", "saturno"};
        // Declaración del HashSet + inicialización
        HashSet<String> planetas = new HashSet<String>(Arrays.asList(planetasArr));
        // Declaración del TreeSet
        TreeSet<Integer> cifras = new TreeSet<Integer>();
        int [] cifrasArr = {2, 8, 5};
        // Rellenado del TreeSet
        for (Integer cifr: cifrasArr) {
            cifras.add (cifr);
        }
        // Rellenado del ArrayList con el HashSet y el TreeSet
        planetasYCifras.add (planetas);
        planetasYCifras.add (cifras);
        // Iterador para el ArrayList
        Iterator<Set> itPYC = planetasYCifras.iterator();
        Set tmpSet;
        Object tmpObj;
        // Recorre el ArrayList
        while (itPYC.hasNext()) {
            tmpSet = itPYC.next();
            // Discriminar tipo de datos en ArrrayList para mostrar su contenido
            tmpObj = null; //
            if (tmpSet instanceof java.util.HashSet) {
                System.out.println ("\n\tElementos del HashSet ");
                Iterator<HashSet> itHS = tmpSet.iterator();
                while (itHS.hasNext()) {
                    if (tmpObj != null) { System.out.print (", "); }
                    tmpObj = itHS.next();
                    System.out.print (tmpObj );
                }
                System.out.print (".");
            } else if (tmpSet instanceof java.util.TreeSet) {
                System.out.println ("\n\tElementos del TreeSet ");
                TreeSet ts = (TreeSet) tmpSet; // conversión de tipo para usar descendingIterator
                Iterator<TreeSet> itTS = ts.descendingIterator();
                while (itTS.hasNext()) {
                    if (tmpObj != null) { System.out.print (", "); }
                    tmpObj = itTS.next();
                    System.out.print (tmpObj );
                }
                System.out.print (".");
            }
        } // fin del while itPYC
    } // fin del main
} // Fin de la clase EjercicioPolimorfismoEste ejercicio me ha hecho bucear en la documentación de las clases java.
He probado varias maneras de llegar al final, todas erróneas hasta conseguirlo.
Espero no haber dado demasiadas vueltas para conseguir las cuatro líneas que da el programa al ejecutarse.

Espero vuestros comentarios.
Saludos.

[César Krall]

Hola Toni, al compilar me salta un warning relacionado con un problema de tipos. Deberías revisar y tratar de eliminar el warning.

Creo que el problema pueda estar relacionado con esto:

if (tmpSet instanceof java.util.HashSet) {
                System.out.println ("\n\tElementos del HashSet ");
                Iterator<HashSet> itHS = tmpSet.iterator();
                while (itHS.hasNext()) {

Ya "estás dentro del HashSet" y ahí quizás deberías declarar el tipo de los elementos dentro del HashSet (por ejemplo String), no HashSet...

Creo que haciendo una revisión en profundidad de los tipos podrías eliminar el warning.

Saludos.

[toni_apr]

Hola César.
Vuelvo a enviar el ejercicio de polimorfismo, pero continuo con el mismo warning
He cambiado como me indicabas el tipo a recorrer  en  la línea:

Iterator<HashSet> itHS = tmpSet.iterator();

por:

Iterator<String> itHS = tmpSet.iterator();

Pero verás que me da el mismo warning.
He hecho varias cosas, todas infructuosas.
He reescrito el código, he descansado y vuelto a retomar el problema, he intentado tomar otra vía, pero ciñéndome a los requerimientos del ejercicio he vuelto al mismo guión.

Así que te pido me ilumines, a ver que concepto me pierdo,o tal vez abordar el problema desde otro lado.

Saludos.

Clase EjercicioPolimorfismoN

Código: [Seleccionar]

import java.util.*;
// import java.util.ArrayList;
// import java.util.HashSet;
// import java.util.TreeSet;
/**
 * Detalles de la clase.
 * @author (Toni)
 * @version (0)
 */
public class EjercicioPolimorfismoN {           
    public static void main (String [] args) {
        System.out.println ("\nVersion N:");
        // Declaración del ArrayList
        ArrayList<Set> planetasYCifras = new ArrayList<Set>();
        String [] planetasArr = {"sol", "luna", "saturno", "pluton"};
        // Declaración del HashSet + inicialización
        HashSet<String> planetas = new HashSet<String>(Arrays.asList(planetasArr));
        // Declaración del TreeSet
        TreeSet<Integer> cifras = new TreeSet<Integer>();
        int [] cifrasArr = {2, 8, 5, -1, 16};
        // Rellenado del TreeSet
        for (Integer cifr: cifrasArr) {
            cifras.add (cifr);
        }
        // Rellenado del ArrayList con el HashSet y el TreeSet
        planetasYCifras.add (planetas);
        planetasYCifras.add (cifras);
        // Iterador para el ArrayList
        Iterator<Set> itPYC = planetasYCifras.iterator();
        Set tmpSet;
        Object tmpObj;
        // Recorre el ArrayList
        while (itPYC.hasNext()) {
            tmpSet = itPYC.next();
            // Discriminar tipo de datos en ArrrayList para mostrar su contenido
            tmpObj = null; //
            if (tmpSet instanceof java.util.HashSet) {
                System.out.println ("El objeto tmpSet es de la clase: " +tmpSet.getClass() + ".\nElementos del HashSet "  + tmpSet.size() );
 //                 HashSet hs = (HashSet) tmpSet;
                Iterator<String> itHS = tmpSet.iterator();
                //                 Iterator<HashSet> itHS = tmpSet.iterator();
                while (itHS.hasNext()) {
                    if (tmpObj != null) { System.out.print (", "); }
                    tmpObj = itHS.next();
                    System.out.print (tmpObj );
                }

                System.out.println (".");   
            } else if (tmpSet instanceof java.util.TreeSet) {

                System.out.println ("El objeto tmpSet es de la clase: " +tmpSet.getClass() + ".\nElementos del TreeSet "  + tmpSet.size() );
                TreeSet ts = (TreeSet) tmpSet; // conversión de tipo para usar descendingIterator

                Iterator<Integer> itTS = ts.descendingIterator();
                // //                 Iterator<TreeSet> itTS = ts.descendingIterator();
                while (itTS.hasNext()) {
                    if (tmpObj != null) { System.out.print (", "); }
                    tmpObj = itTS.next();
                    System.out.print (tmpObj );
                }
                System.out.println (".");
            }
        } // fin del while itPYC
    } // fin del main
} // Fin de la clase EjercicioPolimorfismoN

[César Krall]

Hola toni, para iluminarte tendría que enviarte una linterna pero no sé cómo En un primer intento traté de trabajar sobre tu código tal cual pero después cambié e hice una pequeña reorientación (sólo pequeña). A continuación adjunto el código. Adelanto que no me gusta demasiado la forma que tiene y con seguridad se podría replantear de una forma más adecuada, pero tampoco me parece que sea lo más oportuno detenerse a optimizar este código cuando el objetivo del ejercicio era simplemente comprobar las implicaciones del polimorfismo. Creo que tendrás tiempo más adelante de detenerte en cuestiones de este tipo...

Del código trabajado se pueden sacar algunas conclusiones, a lo mejor entre ellas que a veces no hay que obsesionarse con eliminar los warning (me lo aplico a mí mismo por la parte que me toca ) sino que a veces hay que convivir con ellos.

Código: [Seleccionar]

import java.util.*;
//https://www.aprenderaprogramar.com/foros/index.php?topic=1067.0

public class EjercicioPolimorfismo2 {           
    public static void main (String [] args) {
        // Declaración del ArrayList
        ArrayList<Set> planetasYCifras = new ArrayList<Set>();
        String [] planetasArr = {"sol", "luna", "saturno"};
        // Declaración del HashSet + inicialización
        Set<String> planetas = new HashSet<String>(Arrays.asList(planetasArr));
        // Declaración del TreeSet
        Set<Integer> cifras = new TreeSet<Integer>();
        int [] cifrasArr = {2, 8, 5};
        // Rellenado del TreeSet
        for (Integer cifr: cifrasArr) {
            cifras.add (cifr);
        }
        // Rellenado del ArrayList con el HashSet y el TreeSet
        planetasYCifras.add (planetas);
        planetasYCifras.add (cifras);
        // Iterador para el ArrayList
        Iterator<Set> itPYC = planetasYCifras.iterator();
        Set tmpSet;
        String tmpStr = ""; Integer tmpInt;//
        Object tmpObj;
        // Recorre el ArrayList
        boolean esElPrimero = true;
        while (itPYC.hasNext()) {
            tmpSet = itPYC.next();
            if (tmpSet instanceof java.util.HashSet) {
                System.out.print ("\n\tElementos del HashSet: ");     
                 Iterator itHS = tmpSet.iterator();         
                while (itHS.hasNext()) {
                    if (esElPrimero == false) {System.out.print (", ");}
                    esElPrimero=false;
                    tmpStr = (String)itHS.next();
                    System.out.print (tmpStr);
                }
                System.out.print (".");     
            }
            esElPrimero = true;
           
            if (tmpSet instanceof java.util.TreeSet) {
                System.out.print ("\n\tElementos del TreeSet: ");     
                Iterator itTS = tmpSet.iterator();         
                while (itTS.hasNext()) {
                    if (esElPrimero == false) {System.out.print (", ");}
                    esElPrimero=false;
                    tmpInt = (Integer)itTS.next();
                    System.out.print (tmpInt);
                }
                System.out.print (".");   
           
            }
        } // fin del while itPYC
    } // fin del main
} // Fin de la clase EjercicioPolimorfismo


[toni_apr]

Hola César
Te agradezco, que dentro de la corrección que siempre usas en tus mensajes para corregir, enmendar y aleccionar a los aprendices (entre los que me incluyo), tengas talante para seguir la broma (hablo de mí). Yo te pido que me ilumines, y tú me hablas de una linterna. 

Pero he de decirte, que aunque pueda parecer una broma, tus observaciones traen luz, desvelan misterios y derriban barreras.
¿Recuerdas esos chistes gráficos en que a uno se le enciende una bombilla en la cabeza?
Es lo que pasa cuando uno descubre el camino que estaba fuera de su visión.
Que dice. ¡Eureka! Lo encontré.
Gracias a la bombilla, o la linterna, es igual.

Hablando del código que has enviado, veo que uno de los cambios que has hecho, es que en la declaración del Iterator no especificas el tipo a recorrer.
 

Iterator itHS = tmpSet.iterator();

Cuando yo usaba:
 

Iterator <String> itHS = tmpSet.iterator();

Y ese cambio tan nimio ha eliminado el warning.
Como otras veces, tomo nota de vuestra experiencia.
¡No es obligado declarar el tipo a recorrer en la declaración del Iterator!. Aunque no se si una sintaxis es la formal y la otra es para situaciones... ¿especiales?, o las dos son válidas indistintamente.

De momento tomo nota de tus observaciones.
Saludos.

[César Krall]

Veo que lo cazas todo al vuelo, y no sólo el código...

Si sigues programando verás que uno nunca para de aprender y de sorprenderse. A veces se habla de bugs, a veces de hacks, y a veces de cracks... pero siempre surgen curiosidades y cosas nuevas, seas más o menos veterano. Y una fuente para ir descubriendo todo esto es revisar el código que crean otras personas, siempre te encontrarás algún enfoque nuevo en el que no habías pensado anteriormente.

En el caso del iterator sin indicación del tipo se puede decir que dentro de la filosofía de Java de tipado medio a fuerte es poco recomendable, pero las normas están... para saltárselas de vez en cuando. 

[ZSCFCP]

Buenas tardes.

Despues de leer estos post sobre el ejercicio y dar cabezazos para que me entraran las cosas en la cabeza, os dejo el aporte. Intenté minimizar el código, quedando así:

Código: [Seleccionar]

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

public class Polimorfismo
{
    public static void main(String [] args )
    {
        //DECLARACION ATRIBUTOS.
        List<Set> miLista                  = new ArrayList<Set>();
        Set<Integer>   contenedorDeNumeros = new TreeSet<Integer>();
        Set<String>    contenedorDeCadenas = new HashSet<String>();
        //RELLENO DE LOS 2 SETS.
        contenedorDeNumeros.add(new Integer(2));
        contenedorDeNumeros.add(new Integer(8));
        contenedorDeNumeros.add(new Integer(5));       
        contenedorDeCadenas.add("sol");
        contenedorDeCadenas.add("luna");
        contenedorDeCadenas.add("saturno");
        //CARGA DE LOS SETS DENTRO DEL ARRAYLIST.
        miLista.add(contenedorDeCadenas);
        miLista.add(contenedorDeNumeros);

        //CREACION DE ITERACIONES Y ELEMENTOS AUXILIARES.
        Iterator<Set> it1 = miLista.iterator();
        Iterator      it2 = null;
        String coma = ", "; String punto = ".";
        Set     tmpSet  = null;
        Object  tmpObj = null;
       
        while (it1.hasNext())
        {
            tmpSet = it1.next();

            /** Discriminar tipo de datos en ArrayList para mostrar su contenido */
            // en caso de que la clase instanciada sea un Hashset.
            if (tmpSet instanceof java.util.HashSet)
            {
                System.out.println ("\n El objeto leido del ArrayList es del tipo: " + tmpSet.getClass().getName());
                it2 = tmpSet.iterator();
            }
            // en caso de que la clase instanciada sea un TreeSet, en este caso tenemos que ordenar el iterador descendentemente.
            if (tmpSet instanceof java.util.TreeSet)
            {
                System.out.println ("\n El objeto leido del ArrayList es del tipo: " + tmpSet.getClass().getName());
                TreeSet tmpTS = (TreeSet) tmpSet;
                it2 = tmpTS.descendingIterator();
            }
            while (it2.hasNext())
            {
                if (tmpObj != null) { System.out.print(coma);}
                tmpObj= it2.next();
                System.out.print (tmpObj);
            }
            System.out.print (punto);
           
        }
    }
}

Salu2 y gracias!!

[Jorge lopez]

 Hola  ZSCFCP!

Estuve mirando tu código y me parece un buen trabajo, (aunque mejorable) importas las clases necesarias, creas he inicializas variables correctamente y me pareció muy oportuno el uso del método descendingIterator(); de la clase TreeSet, para devolver por pantalla los objetos tipo Integer exactamente en el orden en que los pide el enunciado del ejercicio.

Te hago los siguientes comentarios enfocados en la mejoría de tu código (que no esta mal)

En java, cosas como:

Código: [Seleccionar]

int primitivo = 10;
Integer objeto = primitivo; Son posibles gracias a los procesos automáticos propios del compilador java "Boxing" y "UnBoxing" lo que podríamos traducir como "envuelto" (referente a un tipo objeto) y "suelto o desenvuelto" (referente a un tipo primitivo). En tu codigo podemos encontrar el siguiente fragmento de código:

Código: [Seleccionar]

contenedorDeNumeros.add(new Integer(2)); el cual podemos sustituir de forma mas sencilla por una sintaxis como:

Código: [Seleccionar]

contenedorDeNumeros.add(2); donde se esta agregando un tipo primitivo, pero el compilador lo envuelve automáticamente (Boxing) debido a que la colección contenedorDeNumeros solo admite tipos Integer.

Referente a las variables de tipo String "coma" y "punto", si te fijas el uso que le das a estas genera un error lógico, puesto que por pantalla se muestra algo no muy apropiado. Para corregir esto, cree la variable tipo String "comaOPunto" cuyo valor estará sujeto a un condicional if, en conjunto de un contador tipo int y del metodo size() aplicado de las colecciones "contenedorDeCadenas" y "contenedorDeNumeros".

También sustituí el método getName(); por el método getSimpleName(); para mayor claridad en lo que se muestra por pantalla, puesto que este solo devuelve el nombre de la clase (ejemp: TreeSet) y no la ruta de la clase
(ejemp: java.util.TreeSet) como lo hace el método getName();

A continuación dejo tu código editado. Trate de no variar mucho tu código, para mantener tu idea.

Código: [Seleccionar]

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

public class Polimorfismo
{
    public static void main(String [] args )
    {
        //DECLARACION ATRIBUTOS.
        List<Set> miLista                  = new ArrayList<Set>();
        Set<Integer>   contenedorDeNumeros = new TreeSet<Integer>();
        Set<String>    contenedorDeCadenas = new HashSet<String>();
        //RELLENO DE LOS 2 SETS.
        //Usamos Una forma mas sencilla de agregar los objetos tipo Integer gracias al proceso automatico que realiza el compilador conocido como "Boxing"
        contenedorDeNumeros.add(2);
        contenedorDeNumeros.add(8);
        contenedorDeNumeros.add(5);       
        contenedorDeCadenas.add("sol");
        contenedorDeCadenas.add("luna");
        contenedorDeCadenas.add("saturno");
        //CARGA DE LOS SETS DENTRO DEL ARRAYLIST.
        miLista.add(contenedorDeCadenas);
        miLista.add(contenedorDeNumeros);
        //CREACION DE ITERACIONES Y ELEMENTOS AUXILIARES.
        Iterator<Set> it1 = miLista.iterator();
        Iterator      it2 = null;
        Set           tmpSet;
        Object        tmpObj;
        String        comaOPunto = "";       
        while (it1.hasNext())
        {
            tmpSet = it1.next();
            int i = 1;//Contador que se utilizara para controlar el valor de la variable tipo String comaOPunto
            /** Discriminar tipo de datos en ArrayList para mostrar su contenido */
            // en caso de que la clase instanciada sea un Hashset.
            if (tmpSet instanceof HashSet) /*Se reduce la sintaxis y se mantiene la misma eficiencia, al sustituir "tmpSet instanceof java.util.HashSet" por
            "tmpSet instanceof HashSet"*/
            {
                System.out.println ("\nEl objeto leido del ArrayList es del tipo: " +
                tmpSet.getClass().getSimpleName() + //Se sustituye el metodo getName(); por el metodo getSimpleName();
                " y contiene los elementos: \n");
                it2 = tmpSet.iterator();
            }
            // en caso de que la clase instanciada sea un TreeSet, en este caso tenemos que ordenar el iterador descendentemente.
            else if (tmpSet instanceof TreeSet)
            {
                System.out.println ("\n\nEl objeto leido del ArrayList es del tipo: " + tmpSet.getClass().getSimpleName() + " y contiene los elementos: \n");
                TreeSet tmpTS = (TreeSet)tmpSet;
                it2 = tmpTS.descendingIterator();
            }
            while (it2.hasNext())
            {               
                tmpObj= it2.next();
                if (i < tmpSet.size()) {comaOPunto = ", ";}else{comaOPunto = ".";}               
                System.out.print (tmpObj+comaOPunto);
                i++;
            }
            i = 1;
        }
    }
}Espero que encuentres algo util.

Saludos!

[palote el de los pericos]

La manera que yo he encontrado para solucionar lo del punto y la coma ha sido usar el mismo booleano que devuelve el método .hasNext() como condición true o false para añadir una coma o un punto.

Código: [Seleccionar]

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

public class CrearHashArrayTreeSet{
private List <Set> lista1;
private Set <String> lista2;
private Set <Integer> lista3;
Iterator <String> iterador1;
Iterator <Integer> iterador2;

public CrearHashArrayTreeSet(){
lista1 = new ArrayList <> ();
lista2 = new HashSet <> (Arrays.asList("luna", "sol", "saturno"));
lista3 = new TreeSet <> (Arrays.asList(2, 8, 5));
}

public void añadirListas(){
lista1.add(lista2);
lista1.add(lista3);
}

public void mostrarArrayList(){
iterador1 = lista2.iterator();
while(iterador1.hasNext()){
System.out.print("\""+iterador1.next()+"\", ");
}
String coma = ", ";
String punto =".";
iterador2 = lista3.iterator();
while(iterador2.hasNext()){
System.out.print(iterador2.next());
if(iterador2.hasNext()){
System.out.print(coma);
}else{
System.out.print(punto);
}
}
}

}

Código: [Seleccionar]

public class TestCrearHashArrayTreeSet{
public static void main(String [] args){
CrearHashArrayTreeSet objmain = new CrearHashArrayTreeSet();
objmain.añadirListas();
objmain.mostrarArrayList();
}
}