Foros aprenderaprogramar.com
Aprender a programar => C, C++, C#, Java, Visual Basic, HTML, PHP, CSS, Javascript, Ajax, Joomla, MySql y más => Mensaje iniciado por: Pepote21 en 06 de Noviembre 2017, 17:17
-
Hola a todos. Os paso mis códigos del ejercicio CU00921C del tutorial pdf de programación Java avanzada.
Código con linkedList= Vehiculo, ListadoVehiculos, Principal
Código con ArrayList=Vehiculo, ListadoVehiculos2, Principal2
Gracias.
Con respecto a los apartados:
a) Con linkedList 18.000.000 nanosegundos.
b) Con arrayList: 6.000.000 nanosegundos.
c) Las diversas pruebas me dan lo mismo, es decir que con ArrayList el tiempo invertido ha sido 1/3 del invertido en LinkedList, o sea, menor y al contrario de lo indicado en el temario. No sé a que se deben las diferencias. Espero no haber hecho algún error en el código. Pero además me salen tiempos mayores en el LinkedList comparándolo también con el código de Erik_Escriche.
Un saludo.
public class Vehiculo {
private int idVehiculo;
private String tipo;
public Vehiculo(){
idVehiculo=0;
tipo="";
}
public Vehiculo(int idVehiculo,String tipo){
this.idVehiculo=idVehiculo;
this.tipo=tipo;
}
public int getIdVehiculo(){
return idVehiculo;
}
public String getTipo(){
return tipo;
}
public void setIdVehiculo(int idVehiculo){
this.idVehiculo=idVehiculo;
}
public void setTipo(String tipo){
this.tipo=tipo;
}
@Override
public String toString(){
return "Vehiculo ID: "+idVehiculo+". Tipo: "+tipo+"\n";
}
}
package practicas.avanzadas.t921C.ejercicio2;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import practicas.avanzadas.t921C.ejercicio.Vehiculo;
/**
*
* @author pepote21
*/
public class ListadoVehiculos {
List<Vehiculo> listaArray;
public ListadoVehiculos(){
listaArray=new LinkedList<Vehiculo>();
}
public void addVehiculo(Vehiculo vehiculo){
listaArray.add(vehiculo);
}
public List<Vehiculo> getLista(){
return listaArray;
}
@Override
public String toString(){
return listaArray.toString();
}
public Iterator<Vehiculo> iterator(){
return new MiIteratorListadoVehiculos();
}
protected class MiIteratorListadoVehiculos implements Iterator<Vehiculo>{//clase interna
public int posicion = 0;
public boolean sepuedeeliminar = false; // Campos
@Override
public boolean hasNext() {
return posicion < listaArray.size();
} // Método
@Override
public Vehiculo next() { // Método
Vehiculo res = listaArray.get(posicion); // Creamos un objeto Persona igual al que recorremos
posicion ++;
sepuedeeliminar = true;
return res;
}
@Override
public void remove() {
if (sepuedeeliminar) {
listaArray.remove(posicion-1);
posicion--;
sepuedeeliminar = false; }
} // Cierre del método remove
} // Cierre de la clase interna
}
package practicas.avanzadas.t921C.ejercicio2;
import java.util.Iterator;
import java.util.Random;
import practicas.avanzadas.t921C.ejercicio.Vehiculo;
/**
* Ejercicio CU00921C aprenderaprogramar.com
* Interfaz list, clase linkeList
* Recorremos linkedList vehículos y eliminamos algunos
* Diferencias entre linkedList y arrayList
* @author pepote21
* @version 20171106
*/
public class Principal {
public static void introVehiculos(ListadoVehiculos lista){//Introducimos 5000 vehículos en la lista
Random rnd=new Random();
String [] tipoVehiculo={"Coche","Camion","Furgoneta","Moto"};
for(int i=0;i<5000;i++){
lista.getLista().add(new Vehiculo(i,tipoVehiculo[rnd.nextInt(4)]));//Atributo tipo establecido de forma aleatoria
}
}
public static void recorrerListaMostrarCantidadVehiculos(ListadoVehiculos lista){//Recorremos lista y mostramos resumen de vehículos de cada tipo
Vehiculo tmp;
int coches=0;
int camiones=0;
int furgonetas=0;
int motos=0;
Iterator<Vehiculo> it=lista.iterator();//Recorremos la lista
while(it.hasNext()){
tmp=it.next();
switch(tmp.getTipo()){//Contamos los elementos de cada tipo
case "Coche":
coches++;
break;
case "Camion":
camiones++;
break;
case "Furgoneta":
furgonetas++;
break;
case "Moto":
motos++;
break;
}
}
System.out.println("Resumen: hay "+coches+" coches, "+camiones+" camiones, "+
furgonetas+" furgonetas y "+motos+" motos.");
}
public static void recorrerListaModificarCantidadVehiculos(ListadoVehiculos lista){
Vehiculo tmp;
String [] tipoVehiculo={"Coche","Camion","Furgoneta","Moto"};
int coches=0;
int camiones=0;
int furgonetas=0;
int motos=0;
int vehiculosEliminados=0;
long antes;
long resultado;
antes=System.nanoTime();
Iterator<Vehiculo> it=lista.iterator();//Recorremos la lista
while(it.hasNext()){
tmp=it.next();
if(!tmp.getTipo().equals("Coche")){
it.remove();
vehiculosEliminados++;
}
}
coches=5000-vehiculosEliminados;
System.out.println("Se han eliminado de la lista "+vehiculosEliminados+" vehiculos quedando "+coches+" coches");
for(int i=0;i<vehiculosEliminados;i++){
lista.getLista().add(new Vehiculo(coches+i+1,tipoVehiculo[0]));
coches++;
}
resultado=System.nanoTime()-antes;
System.out.println("Se han invertido "+resultado+" nanosegundos en eliminar y añadir vehiculos");
System.out.println("Resumen: hay "+coches+" coches, "+camiones+" camiones, "+
furgonetas+" furgonetas y "+motos+" motos.");
}
public static void main(String[]args){
ListadoVehiculos lista=new ListadoVehiculos();
introVehiculos(lista);
recorrerListaMostrarCantidadVehiculos(lista);
recorrerListaModificarCantidadVehiculos(lista);
}
}
package practicas.avanzadas.t921C.ejercicio2;
import java.util.Iterator;
import java.util.ArrayList;
import java.util.List;
import practicas.avanzadas.t921C.ejercicio.Vehiculo;
/**
*
* @author pepote21
*/
public class ListadoVehiculos2 {
List<Vehiculo> listaArray;
public ListadoVehiculos2(){
listaArray=new ArrayList<Vehiculo>();
}
public void addVehiculo(Vehiculo vehiculo){
listaArray.add(vehiculo);
}
public List<Vehiculo> getLista(){
return listaArray;
}
@Override
public String toString(){
return listaArray.toString();
}
public Iterator<Vehiculo> iterator(){
return new MiIteratorListadoVehiculos();
}
protected class MiIteratorListadoVehiculos implements Iterator<Vehiculo>{//clase interna
public int posicion = 0;
public boolean sepuedeeliminar = false; // Campos
@Override
public boolean hasNext() {
return posicion < listaArray.size();
} // Método
@Override
public Vehiculo next() { // Método
Vehiculo res = listaArray.get(posicion); // Creamos un objeto Persona igual al que recorremos
posicion ++;
sepuedeeliminar = true;
return res;
}
@Override
public void remove() {
if (sepuedeeliminar) {
listaArray.remove(posicion-1);
posicion--;
sepuedeeliminar = false; }
} // Cierre del método remove
} // Cierre de la clase interna
}
package practicas.avanzadas.t921C.ejercicio2;
import java.util.Iterator;
import java.util.Random;
import practicas.avanzadas.t921C.ejercicio.Vehiculo;
/**
*
* @author pepote21
*/
public class Principal2 {
public static void introVehiculos(ListadoVehiculos2 lista){//Introducimos 5000 vehículos en la lista
Random rnd=new Random();
String [] tipoVehiculo={"Coche","Camion","Furgoneta","Moto"};
for(int i=0;i<5000;i++){
lista.getLista().add(new Vehiculo(i,tipoVehiculo[rnd.nextInt(4)]));//Atributo tipo establecido de forma aleatoria
}
}
public static void recorrerListaMostrarCantidadVehiculos(ListadoVehiculos2 lista){//Recorremos lista y mostramos resumen de vehículos de cada tipo
Vehiculo tmp;
int coches=0;
int camiones=0;
int furgonetas=0;
int motos=0;
Iterator<Vehiculo> it=lista.iterator();//Recorremos la lista
while(it.hasNext()){
tmp=it.next();
switch(tmp.getTipo()){//Contamos los elementos de cada tipo
case "Coche":
coches++;
break;
case "Camion":
camiones++;
break;
case "Furgoneta":
furgonetas++;
break;
case "Moto":
motos++;
break;
}
}
System.out.println("Resumen: hay "+coches+" coches, "+camiones+" camiones, "+
furgonetas+" furgonetas y "+motos+" motos.");
}
public static void recorrerListaModificarCantidadVehiculos(ListadoVehiculos2 lista){
Vehiculo tmp;
String [] tipoVehiculo={"Coche","Camion","Furgoneta","Moto"};
int coches=0;
int camiones=0;
int furgonetas=0;
int motos=0;
int vehiculosEliminados=0;
long antes;
long resultado;
antes=System.nanoTime();
Iterator<Vehiculo> it=lista.iterator();//Recorremos la lista
while(it.hasNext()){
tmp=it.next();
if(!tmp.getTipo().equals("Coche")){
it.remove();
vehiculosEliminados++;
}
}
coches=5000-vehiculosEliminados;
System.out.println("Se han eliminado de la lista "+vehiculosEliminados+" vehiculos quedando "+coches+" coches");
for(int i=0;i<vehiculosEliminados;i++){
lista.getLista().add(new Vehiculo(coches+i+1,tipoVehiculo[0]));
coches++;
}
resultado=System.nanoTime()-antes;
System.out.println("Se han invertido "+resultado+" nanosegundos en eliminar y añadir vehiculos");
System.out.println("Resumen: hay "+coches+" coches, "+camiones+" camiones, "+
furgonetas+" furgonetas y "+motos+" motos.");
}
public static void main(String[]args){
ListadoVehiculos2 lista=new ListadoVehiculos2();
introVehiculos(lista);
recorrerListaMostrarCantidadVehiculos(lista);
recorrerListaModificarCantidadVehiculos(lista);
}
}
-
Buenas Pepote21, al hacer pruebas he obtenido algo parecido a lo que indicadas (en mi caso unos 8.000.000 de tiempo con ArrayList frente a 24.000.000 con LinkedList aproximadamente). El tiempo invertido depende del computador sobre el que se ejecute el código.
En mi caso he obtenido esto:
EJECUCIONES CON LINKEDLIST
Resumen: hay 1238 coches, 1278 camiones, 1261 furgonetas y 1223 motos.
Se han eliminado de la lista 3762 vehiculos quedando 1238 coches
Se han invertido 23901571 nanosegundos en eliminar y añadir vehiculos
Resumen: hay 5000 coches, 0 camiones, 0 furgonetas y 0 motos.
Resumen: hay 1280 coches, 1260 camiones, 1231 furgonetas y 1229 motos.
Se han eliminado de la lista 3720 vehiculos quedando 1280 coches
Se han invertido 33130768 nanosegundos en eliminar y añadir vehiculos
Resumen: hay 5000 coches, 0 camiones, 0 furgonetas y 0 motos.
Resumen: hay 1247 coches, 1264 camiones, 1245 furgonetas y 1244 motos.
Se han eliminado de la lista 3753 vehiculos quedando 1247 coches
Se han invertido 21486611 nanosegundos en eliminar y añadir vehiculos
Resumen: hay 5000 coches, 0 camiones, 0 furgonetas y 0 motos.
EJECUCIONES CON ARRAYLIST
Resumen: hay 1235 coches, 1267 camiones, 1271 furgonetas y 1227 motos.
Se han eliminado de la lista 3765 vehiculos quedando 1235 coches
Se han invertido 6992139 nanosegundos en eliminar y añadir vehiculos
Resumen: hay 5000 coches, 0 camiones, 0 furgonetas y 0 motos.
Resumen: hay 1225 coches, 1268 camiones, 1225 furgonetas y 1282 motos.
Se han eliminado de la lista 3775 vehiculos quedando 1225 coches
Se han invertido 9395982 nanosegundos en eliminar y añadir vehiculos
Resumen: hay 5000 coches, 0 camiones, 0 furgonetas y 0 motos.
Resumen: hay 1272 coches, 1230 camiones, 1226 furgonetas y 1272 motos.
Se han eliminado de la lista 3728 vehiculos quedando 1272 coches
Se han invertido 9999829 nanosegundos en eliminar y añadir vehiculos
Resumen: hay 5000 coches, 0 camiones, 0 furgonetas y 0 motos.
Hay una cosa que no me parece correcta en cómo has resuelto el ejercicio: tú no has implementado las listas como LinkedList ni como ArrayList, sino dentro de una clase creada por tí donde tienes como atributo de clase un LinkedList ó ArrayList. Es decir, no has trabajado indirectamente con las clases estructuras de datos en Java, sino indirectamente. Eso puede tener consecuencias que habría que analizar y no es lo que proponía el ejercicio, por eso veo más correcta una solución como la que se propone en https://www.aprenderaprogramar.com/foros/index.php?topic=5781.0
El ejercicio tal y como lo has planteado, desde mi punto de vista, no cumple con lo que se pedía
Salu2
-
Hola Ogramar.
Agradezo de nuevo tu correción. No la esperaba ya después de varios meses.
Aunque ya no haya temarios de java en aprenderaprogramar.com sigo estudiando mucho java y de vez en cuando suelo entrar en la web de aprenderaprogramar.com, como hice ayer.
Me equivoqué en el título del anterior ejercicio y en este tienes razón. A veces me desvió del enunciado del ejercicio debido a querer presentar ejercicios diferentes (no copiar) sin tener en cuenta lo que dice el ejercicio.
Nada más pueda repasaré este ejercicio.
Java, aunque sigue costándome, a día de hoy ya he realizado mi primer programa, una agenda prototipo en modo MVC a la cual tengo aún que añadir clases para suplementarla más.
Un saludo.