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

Hola a todos. Aquí dejo mi implementación del ejercicio CU00921C del tutorial pdf de programación avanzada en Java. He implementado ambas opciones, ArrayList y LinkedList, en el mismo programa, para facilitarme la comparación de los resultados y practicar la aplicación del polimorfismo.

Los procedimientos de creación de las listas y de eliminación-inserción, los he implementado como métodos de la clase principal. Además, aunque no se pedía en el ejercicio, he incluido un método para mostrar el contenido de las listas y lo he usado para mostrar los resúmenes.


Clase Vehiculo

package cu00921c.ejercicio;

public class Vehiculo {
    private int idVehiculo;
    private String tipo;
   
    public Vehiculo(int id, String tipo){
        idVehiculo=id;
        this.tipo=tipo;
    }
    public void setIdVehiculo(int id){idVehiculo=id;}
    public void setTipo(String tipo){this.tipo=tipo;}
    public int getIdVehiculo(){return idVehiculo;}
    public String getTipo(){return tipo;}
    @Override
    public String toString(){
        return "Vehiculo-> ID: "+idVehiculo+" Tipo: "+tipo;
    }
}


Clase Principal

package cu00921c.ejercicio;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;

public class CU00921CEjercicio {

    public static void main(String[] args) {
        List<Vehiculo> listaarray = new ArrayList();
        List<Vehiculo> listalinked = new LinkedList();
        String[] tipos ={"Coche", "Camion", "Furgoneta", "Moto"};
        cargarLista(listaarray,tipos);
        System.out.println("Ejecución con ArrayList\n");
        imprimirLista(listaarray,"inicial",false);
        eliminarInsertar(listaarray);
        System.out.println("\nEjecución con LinkedList\n");
        cargarLista(listalinked,tipos);
        imprimirLista(listalinked,"inicial",false);
        eliminarInsertar(listalinked);
       
    }
    //Método que permite imprimir la lista o sólo el resumen
    private static void imprimirLista(List<Vehiculo> lista, String momento, boolean resumen){
        int coches=0, camiones=0, furgonetas=0, motos=0;
        for (int i=0;i<lista.size();i++){
            if(resumen){System.out.println(lista.get(i));}
            switch (lista.get(i).getTipo()) {
                case "Coche":
                    coches++;
                    break;
                case "Camion":
                    camiones++;
                    break;
                case "Furgoneta":
                    furgonetas++;
                    break;
                default:
                    motos++;
                    break;
            }
        }
        System.out.println("Resumen lista "+momento+": hay "+coches+" Coches, "+camiones+" Camiones, "+furgonetas+ " Furgonetas y "+motos+" Motos");
    }
   
    //Método para general la lista
    private static void cargarLista(List<Vehiculo> lista, String[] tipos){
        Random rnd = new Random();
        for (int i=1;i<=5000;i++){
            lista.add(new Vehiculo(i,tipos[rnd.nextInt(4)]));
        }       
    }
    //Método para eliminar-insertar
    private static void eliminarInsertar(List<Vehiculo> lista){
        long inicio, fin;
        Vehiculo tmp;
        int eliminados=0;
        int ultimoId;
        //Eliminar elementos no Coche
        inicio = System.nanoTime();
        Iterator<Vehiculo> it = lista.iterator();
        while(it.hasNext()){
            tmp=it.next();
            if(!tmp.getTipo().equals("Coche")){it.remove();eliminados++;}
        }
        //Insertar tantos vehiculos Coche como se han eliminado
        ultimoId=lista.get(lista.size()-1).getIdVehiculo();
        for (int i=ultimoId; i<ultimoId+eliminados;i++){
            lista.add(new Vehiculo(i,"Coche"));
        }
        fin=System.nanoTime();
        System.out.println("Una vez realizada la eliminación-inserción:");
        System.out.println("Tiempo empleado en eliminación-inserción (en nanosegundos): "+(fin-inicio));
        imprimirLista(lista,"final",false);       
    }   
}

En cuanto a las preguntas del ejercicio, estas serían mis respuestas:

a y b) Resultados:


Ejecución con ArrayList

Resumen lista inicial: hay 1264 Coches, 1193 Camiones, 1267 Furgonetas y 1276 Motos
Una vez realizada la eliminación-inserción:
Tiempo empleado en eliminación-inserción (en nanosegundos): 4065861
Resumen lista final: hay 5000 Coches, 0 Camiones, 0 Furgonetas y 0 Motos

Ejecución con LinkedList

Resumen lista inicial: hay 1298 Coches, 1250 Camiones, 1237 Furgonetas y 1215 Motos
Una vez realizada la eliminación-inserción:
Tiempo empleado en eliminación-inserción (en nanosegundos): 1971780
Resumen lista final: hay 5000 Coches, 0 Camiones, 0 Furgonetas y 0 Motos
c) Después de varias ejecuciones, se observa que el tiempo empleado usando ArrayList es siempre más del doble del que se obtiene usando LinkedList, lo que creo que se debe a que, después del borrado, las nuevas inserciones se producen al final (en este caso concreto se han debido producir 3.702 inserciones.

Es cierto que se han producido el mismo número de eliminaciones, que la mayoría de ellas se han debido producir en posiciones intermedias, y que éstas son más rápidas (según se nos indica en el texto) con ArrayList, por lo que deduzco que la eficiencia de LinkedList en las inserciones en posiciones finales supera con creces la ventaja en eficiencia de eliminaciones en posiciones intermedias obtenidas con ArrayList.

Hola a todos. Dejo aquí mi solución al ejercicio CU00919C del curso gratuito de Java avanzado para que la comentéis y me ayudéis a mejorarla. En ella he implementado una clase EntradaTeclado para pedir la entrada de datos int por teclado y así evitar que el programa se interrumpa al no introduir un valor no entero.


Clase Animal

package cu00919c.ejercicio;

public class Animal {
    private String especie, nombre;
    private double peso;
    private int patas;
   
    public Animal(String especie, String nombre, double peso, int patas){
        this.especie=especie;
        this.nombre=nombre;
        this.peso=peso;
        this.patas=patas;
    }
    public void setEspecie(String e){especie=e;}
    public void setNombre(String n) {nombre=n;}
    public void setPeso(double p){peso=p;}
    public void setPatas(int patas){this.patas=patas;}
    public String getEspecie(){return especie;}
    public String getNombre(){return nombre;}
    public double getPeso(){return peso;}
    public int getPatas(){return patas;}
    @Override
    public String toString(){
        return "Especie: "+especie+", Nombre: "+nombre+", peso: "+peso+" kg, patas: "+patas;
    }
}


Clase ListaDeAnimales

package cu00919c.ejercicio;

import java.util.ArrayList;
import java.util.Iterator;

public class ListaDeAnimales {
    private ArrayList<Animal> lista=null;
   
    public ListaDeAnimales(){lista=new ArrayList<Animal>();}
   
    public void addAnimal(Animal a){lista.add(a);}
   
    public ArrayList<Animal> getLista(){return lista;}
   
    public int size(){return lista.size();}
    public void remove(int i){lista.remove(i);}
   
    public Iterator<Animal> iterator(){return new Iterador();}
   
   
    public void imprimir(){
        Iterator<Animal> it = lista.iterator();
        int numero=1;
        while(it.hasNext()){
            System.out.print(it.next()+", número "+numero+"\n");
            numero++;
        }

    }
   
    protected class Iterador implements Iterator<Animal>{
        public int posicion=0;
        public boolean eliminable=false;
        @Override
        public boolean hasNext(){return posicion<lista.size();}
        @Override
        public Animal next(){
            Animal animal=lista.get(posicion);
            posicion++;
            eliminable=true;
            return animal;
        }
        @Override
        public void remove(){
            if(eliminable){
                lista.remove(posicion-1);
                posicion--;
                eliminable=false;
            }
        }
    }
   
}


Clase EntradaTeclado

package cu00919c.ejercicio;
import java.util.Scanner;
import java.util.InputMismatchException;

public class EntradaTeclado {
    Scanner sc;
    EntradaTeclado(){}
   
    public int entero(){
        sc=new Scanner(System.in);
        int numero;
        try{numero=sc.nextInt();}
        catch(InputMismatchException e){
            System.out.print("Entrada no válida. ");
            return 0;
        }
        return numero;
    }
}


Clase principal

package cu00919c.ejercicio;

public class CU00919CEjercicio {

    public static void main(String[] args) {
        int numero=0;
        EntradaTeclado entrada=new EntradaTeclado();
        ListaDeAnimales lista=new ListaDeAnimales();
        lista.addAnimal(new Animal("pantera","Penelope",98.55,4));
        lista.addAnimal(new Animal("loro amazónico","Juanito",3.67,2));
        lista.addAnimal(new Animal("perro gran danés","Artur",38.77,4));
        lista.addAnimal(new Animal("mono de Tanzania","Monk",55.32,2));
       
        System.out.println("Los animales de la lista son:");
        lista.imprimir();
        do{
        System.out.print("\n¿Qué número desea eliminar?: ");
        numero=entrada.entero();
        if(numero<1||numero>lista.size()){System.out.println("Debe introducir un número entre 1 y "+lista.size());}
        }while(numero<1||numero>lista.size());
        lista.remove(numero-1);
        System.out.println("Los animales de la lista son:");
        lista.imprimir();       
    }   
}

Gracias a todos.

Hola.

En mi solución solo he usado la interface Comparable, no la Cloneable, ya que no se trata de guardar la lista de personas ordenadas, sino de mostrarlas ordenadas, por lo que me limito a crear un array adicional de 5 personas cuyos elementos apuntan ordenadamente, según el criterio de ordenación especificado, a las instancias de Persona que se crean al principio del método main. Así se usaría menos memoria.

No he encontrado la manera de sobreescribir el método compareTo de forma que pueda usarse para cualquiera de los dos criterios de ordenación, por lo que he tenido que crear otro método para la altura (he considerado que es más habitual ordenar por edades).

Ahí adjunto mi solución. Espero las críticas del resto de usuarios.

Clase Persona
public class Persona implements Comparable<Persona>{
    private String nombre;
    private int edad, altura;
   
    public Persona(String nombre, int edad, int altura){
        this.nombre=nombre;
        this.edad=edad;
        this.altura=altura;
    }
   
    public String getNombre(){return this.nombre;}
    public int getEdad(){return this.edad;}
    public int getAltura(){return this.altura;}
   
    @Override
    public int compareTo(Persona o){
        int resultado=0;
        if (this.edad>o.edad){ resultado=1; }
        else if (this.edad<o.edad){ resultado=-1; }
        return resultado;
        }
   
    public int compareToAltura(Persona o){
        int resultado=0;
        if(this.altura>o.altura){resultado=+1;}
        else if (this.altura<o.altura){resultado=-1;}
        return resultado;
    }
    @Override
    public String toString(){
        return this.nombre+" - Altura: "+this.altura+" - Edad: "+this.edad;
    }
}

Clase con el método main
public class CU00913C {

    public static void main(String[] args) {
        Persona[] personas = new Persona[5];
        personas[0] = new Persona("Mario", 22, 187);
        personas[1] = new Persona("Pepe", 52, 173);
        personas[2] = new Persona("Manuel", 27, 158);
        personas[3] = new Persona("David", 25, 164);
        personas[4] = new Persona("Alberto", 80, 184);
        Persona[] personasOrdenadas = new Persona[5];
       
        System.out.println("Personas sin ordenar");
        for(Persona tmp:personas){System.out.print(tmp.toString()+"\n");}
        System.out.println();
       
        System.out.println("Personas ordenadas por altura");
        personasOrdenadas=OrdenarAltura(personas);
        for(Persona tmp:personasOrdenadas){System.out.print(tmp.toString()+"\n");}
        System.out.println();
       
        System.out.println("Personas ordenadas por edad");
        personasOrdenadas=OrdenarEdad(personas);
        for(Persona tmp:personasOrdenadas){System.out.print(tmp.toString()+"\n");}
        System.out.println();
       
}
    //Ordena crecientemente por edades sin clonar ls objetos persona
    public static Persona[] OrdenarEdad(Persona[] personas){
        Persona[] ordenado = new Persona[5];
        ordenado[0]=personas[0];
        for (int i=1;i<5;i++){
            int j=i;
            while (j>0&&personas[i].compareTo(ordenado[j-1])<0){
                ordenado[j]=ordenado[j-1];
                j--;
            }
            ordenado[j]=personas[i];
        }
        return ordenado;
    }
   
    //Ordena decrecientemente por alturas sin clonar los objetos persona
    public static Persona[] OrdenarAltura(Persona[] personas){
        Persona[] ordenado = new Persona[5];
        ordenado[0]=personas[0];
        for (int i=1;i<5;i++){
            int j=i;
            while (j>0&&personas[i].compareToAltura(ordenado[j-1])>0){
                ordenado[j]=ordenado[j-1];
                j--;
            }
            ordenado[j]=personas[i];
        }
        return ordenado;
    }