Foros aprenderaprogramar.com
Didáctica y divulgación de la programación

Buah, yo cuando tuve que hacer este ejercicio también me hice un lío enorme. Luego, al ir avanzando, parece que las cosas van encontrando ellas solas su lugar en la mente y es más sencillo.

¡Hola maxplanck!

El ejercicio funciona correctamente, pero hay algunas cosas que puedes cambiar para mejorarlo.

Has hecho una cosa que yo también hacía al principio: cada vez que quieres leer un mensaje de teclado, creas un objeto Scanner; esto no es necesario, basta con crear uno. Lo he puesto en la parte de arriba, donde se declaran los atributos de la clase, para que puedas usarlo en todos los métodos.

En segundo lugar, no necesitas escribir while (it.hasNext()==true) cuando usas un iterador porque it.hasNext() ya te devuelve un booleano. Es decir, bastaría con poner while (it.hasNext()). Para hacerlo más sencillo, he cambiado un poco el código del método preguntar() y he puesto que la condición sea while (ent.equalsIgnoreCase("S")) (así te ahorras la variable booleana si).

He borrado el null del iterador, porque no es necesario. También he eliminado la palabra static de los métodos.

ListaCantantesFamosos
import java.util.*;
public class ListaCantantesFamosos {
    private static ArrayList<CantanteFamoso> lista1;
    private Scanner tec;

    public ListaCantantesFamosos () {
        lista1 = new ArrayList<CantanteFamoso>();
        tec = new Scanner (System.in);

    }

    public void listaInicial ()  {
        CantanteFamoso cantorA = new CantanteFamoso ("Siniestro Total" , "¿Cuándo se come aquí?");
        lista1.add(cantorA);
        CantanteFamoso cantorb = new CantanteFamoso ("The Smiths" , "¿The Queen is dead?");
        lista1.add(cantorb);
    }
    //public static String getDisc1 (int poss2) {return (lista1.get(poss2)).getDisco();}
    public void listar() {
        CantanteFamoso cantorX;
        Iterator<CantanteFamoso> it = lista1.iterator();
        while (it.hasNext()) {
            cantorX = it.next();
            System.out.println ("Nombre del cantante/grupo: " + cantorX.getNombre() + ";    Nombre del disco: " + cantorX.getDisco());
        }
       
    }

    public void preguntar(){
        String ent = "S";
        while (ent.equalsIgnoreCase("S")){
            System.out.println ("¿Desea añadir otra entrada?: S/N");           
            ent = tec.nextLine();
            while (!ent.equalsIgnoreCase("N")&&!ent.equalsIgnoreCase("S")) {
                System.out.println ("Entrada no válida.");
                ent = tec.nextLine();
            }               
            if (ent.equalsIgnoreCase ("S")) {
                nuevo();
            }
            else if (ent.equalsIgnoreCase ("n")) {
                System.out.println ("Fin del programa, gracias por colaborar.");
                System.out.println ("La lista definitiva es:");
                listar();
            }
        }
    }

    public void nuevo () {
        CantanteFamoso cantorX;
        String ent1 = "";
        System.out.println ("Introduzca nuevo nombre de cantante/grupo.");       
        ent1 = tec.nextLine();
        String ent2 = "";
        System.out.println ("Introduzca nuevo nombre disco.");
        ent2 = tec.nextLine();           
        cantorX = new CantanteFamoso(ent1,ent2);
        lista1.add(cantorX);
        System.out.println ("La nueva lista  es:");
        listar();
    }
}
En la clase main, has hecho una cosa un poco rara, y creo que por eso te has visto obligado luego a poner static en los métodos de ListaCantantesFamosos. Has creado un objeto de tipo ListaCantantesFamosos al que has llamado listaT, pero luego, en vez de aplicar los métodos a este objeto, has escrito ListaCantantesFamosos.listar(), etc. Yo lo haría así:

TestLista
import java.util.*;
public class TestLista {

   public static void main (String[] args) {
       ListaCantantesFamosos listaT = new ListaCantantesFamosos ();
       listaT.listaInicial();
       System.out.println ("La lista actual contiene las siguientes entradas:");
       listaT.listar();
       listaT.preguntar();
       
    }
}

Espero que te sirva. ¡Un saludo!

Agradezco tu comentario, ESOJ. Me parecen buenas simplificaciones.

¡Un saludo!

Buenas.

Creo que no se trata de erratas muy importantes, pero por si acaso abro este hilo.

En la entrega CU00915C se menciona varias veces a la clase Persona cuando, me parece, la explicación se está refiriendo a la clase ConjuntoPersonas:

Para poder devolver un objeto de tipo Iterator (que es algo a lo que al fin y al cabo nos obliga la interface Iterable) necesitamos instanciar un objeto Iterator y esto no podemos hacerlo directamente. Para resolver este problema, recurrimos a definir una clase interna dentro de la clase Persona denominada MiIteratorPersona, que implementará la interface Iterator, y que por tanto nos permitirá devolver una instancia de Iterator para nuestra clase Persona.

El acceso elegido para crear la clase MiIteratorPersona es protected. ¿Por qué? Porque esta clase no tiene interés que sea visible desde otras clases. Unicamente nos interesa que sea visible desde la clase Persona o subclases de la clase Persona.

En el siguiente párrafo, donde pone "para implementar la interface iterator" creo que debería poner "para implementar la interfaz Iterable":

A nivel de términos es un poco confuso, pero cuando te acostumbres y realices unos cuantos ejercicios te resultará más fácil. Decimos que es confuso porque parece un trabalenguas: para implementar la interface iterator hemos de sobreescribir el método iterator(), y para ello hemos de poder devolver un objeto Iterator, lo cual logramos creando una clase interna que implementa la interface Iterator. Como decimos, una especie de trabalenguas.

¡Saludos!

Buenas maxplanck.

Creo que el warning te sale por esta línea:

ArrayList<String> lista3 = new ArrayList();
Me ha pasado algunas veces y siempre es porque en un Iterador, en un List o en un ArrayList me he dejado la parte de <E>. Escribe en tu código new ArrayList<String>();.

¡Saludos y Feliz Navidad!

Buenas a todos.

Esta es mi solución al ejercicio de la entrega CU00919C del curso Lenguaje de Programación Java Nivel Avanzado I.

Crea una clase denominada Animal con los atributos especie (String), nombre (String), peso (double) y patas (int).

Crea una clase ListaDeAnimales que permita crear una colección de animales y que permita el recorrido de la colección usando un iterador.

Crea una clase con el método main donde se introduzcan 4 animales en la lista y se muestren por pantalla usando el iterador e indicando el número que ocupan en la lista y el total de animales en la lista.

Tras esto, debe solicitarse al usuario que indique un número de la lista a eliminar. Usando el método remove() debe eliminarse ese animal de la lista y volver a mostrarse la lista indicando el nuevo número que ocupa cada animal en la lista y el total de animales en la lista.

Clase Animal.
package javaAvanzado;
public class Animal {
    //Atributos.
    private String especie;
    private String nombre;
    private double peso;
    private int patas;
    //Constructor.
    public Animal (String especie, String nombre, double peso, int patas) {
        this.especie=especie;
        this.nombre=nombre;
        this.peso=peso;
        this.patas=patas;
    }
    //Setters y getters.
    public void setEspecie (String especie) {this.especie=especie;}
    public void setNombre (String nombre) {this.nombre=nombre;}
    public void setPeso (double peso) {this.peso=peso;}
    public void setPatas (int patas) {this.patas=patas;}
    public String getEspecie() {return especie;}
    public String getNombre() {return nombre;}
    public double getPeso() {return peso;}
    public double getPatas() {return patas;}
    @Override
    public String toString() {
        return "Especie: "+especie+". Nombre: "+nombre+". Peso: "+peso+". Patas: "+patas+".\n";
    }
}
Clase ListaAnimales.
package javaAvanzado;
import java.util.ArrayList;
import java.util.Iterator;
public class ListaAnimales {
    //Atributo.
    private ArrayList<Animal> listaAnimales;
    //Constructor.
    public ListaAnimales () {listaAnimales= new ArrayList<Animal> ();}
    //Métodos.
    public Animal getAnimal(int lugar) {return listaAnimales.get(lugar);}
    public int getLongitud() {return listaAnimales.size();}
    public void addAnimal(Animal animal) {listaAnimales.add(animal);}
    @Override
    public String toString() {return listaAnimales.toString();}
    public Iterator<Animal> iterator() {return new MiIteradorListaAnimales();}
    //Clase Interna.
    public class MiIteradorListaAnimales implements Iterator<Animal> {
        //Atributos.
        protected int posicion;
        protected boolean sepuedeeliminar;
        //Constructor.
        public MiIteradorListaAnimales () {
            posicion=0;
            sepuedeeliminar=false;
        }
        //Método.
        public int getPosicion() {return posicion;}
        //Métodos sobrescritos.       
        @Override
        public boolean hasNext() {return posicion<listaAnimales.size();}
        @Override
        public Animal next() {Animal nextAnimal = listaAnimales.get(posicion);
            posicion++;
            sepuedeeliminar=true;
            return nextAnimal;}
        @Override
        public void remove() {if(sepuedeeliminar) {
            listaAnimales.remove(posicion-1);
            posicion--;
            sepuedeeliminar=false;}
        }
    }
}
Clase principal.
package javaAvanzado;
import java.util.Iterator;
import java.util.Scanner;
public class MainAnimal {
    public static void main (String [] args) {
        Scanner entrada= new Scanner(System.in);
        int respuesta;
        int contador = 1;
        ListaAnimales miLista = new ListaAnimales();
        miLista.addAnimal(new Animal("pantera", "Penélope", 98.55, 4));
        miLista.addAnimal(new Animal("loro", "Juan", 3.00, 2));
        miLista.addAnimal(new Animal ("perro", "Arthur", 37.66, 4));
        miLista.addAnimal(new Animal ("orangután", "Monje", 40.10, 2));       
        System.out.println ("Los animales de la lista son los siguientes: ");       
        Iterator<Animal> it;
        it = miLista.iterator();
        while (it.hasNext()) {
            Animal auxiliar = it.next();
            System.out.print ("Número "+(contador)+". "+auxiliar.toString());
            contador++;
        }
        System.out.println ("Número total de animales: "+miLista.getLongitud()+".");
        System.out.println ("¿A qué animal quieres sacar de la lista? Introduce el número.");
        respuesta = entrada.nextInt();       
        contador=1;
        Iterator <Animal> it2;
        it2= miLista.iterator();
        while(it2.hasNext()){
            Animal auxiliar = it2.next();       
            if (contador==respuesta) {it2.remove();}
            contador++;
        }
        System.out.println ("Los animales de la lista son los siguientes: ");
        contador=1;
        Iterator<Animal> it3;
        it3 = miLista.iterator();
        while (it3.hasNext()) {
            Animal auxiliar = it3.next();
            System.out.print ("Número "+(contador)+". "+auxiliar.toString());
            contador++;
        }
        System.out.println ("Número total de animales: "+miLista.getLongitud()+".");
    }
}       
¡Saludos!

Buenas.

Esta es mi solución al ejercicio de la entrega CU00914C de Java Nivel Avanzado I sobre el uso de StringBuilder y StringBuffer.

package javaAvanzado;
public class HolaCaracola {
    public static void main (String [] args) {
        StringBuilder cadena = new StringBuilder("Hola Caracola");
        System.out.println (cadena);
        System.out.println ("Capacidad del StringBuilder: "+cadena.capacity()+". Longitud del StringBuilder: "+cadena.length()+".");
        System.out.println (cadena.replace(cadena.indexOf("ola Caracola"), cadena.indexOf(" Caracola"),"ay").append("s"));
        int cantidadDeCaracolas =5000;
        cadena.append(5000);
        cadena.delete(cadena.indexOf("Caracolas"), cadena.indexOf("5000"));
        cadena.append(" Caracolas");
        System.out.println (cadena);
        System.out.println (cadena.append(" en el mar"));       
        String otraCadena = cadena.substring(cadena.indexOf(" mar"));
        System.out.println (otraCadena);
        System.out.println ("Capacidad del StringBuilder: "+cadena.capacity()+". Longitud del StringBuilder: "+cadena.length()+".");
    }
}
Un saludo.

Confusión solucionada. He revisado la entrega en la que se explicaban ambos conceptos y ya me he dado cuenta de que también se diferencian en que los arrays pueden almacenar ambos tipos de datos, pero los ArrayList solo objetos.

Lo veo todo bien. Podrías ahorrar un poco de código en la parte de los intentos si en el último else if (...) usas simplemente else:

import java.util.Scanner;
import java.util.Random;
/**
 * Testea el funcionamiento de Adivinar
 *
 * @author Chompy129
 * @version 1.0
 */
public class Adivinar{
    public static void main(String [] args){
        Random aleatorio= new Random();
        int numeroMaquina= aleatorio.nextInt(100);
        Scanner entradaS= new Scanner(System.in);
        int numeroUsuario= 0;
        int intentos= 0;
       
        System.out.println("Inicia el juego. Tienes 10 intentos.");
        System.out.print("Elige un número: ");
        while(numeroUsuario != numeroMaquina && intentos < 10){
            numeroUsuario= Integer.parseInt(entradaS.nextLine());           
            intentos++;

            if(intentos == 10){
System.out.println("Ha superado el número de intentos.");
}   
            else if(numeroUsuario == numeroMaquina){
                System.out.println("¡Has acertado!");
            }
            else if(numeroUsuario > numeroMaquina){
                System.out.print("El número es muy alto. Intente con uno mas bajo: ");
            }
            else {
                System.out.print("El número es muy bajo. Intente con uno mas alto: ");
            }           
        }
System.out.println("Gracias por jugar");
    }
}
¡Saludos!

Claro, ayudaré a responder a los temas en los que me sienta más o menos seguro de lo que estoy diciendo, jeje. ¡Feliz Navidad!