Hola a todos, hoy os dejo una serie de ejercicios de Java para practicar todo aquello que hemos explicado en anteriores posts, haciendo hincapié en las listas enlazadas en Java.
Todos los ejercicios que proponemos están resueltos en este mismo post, intenta hacerlo por ti mismo y si te quedas atascado puedes mirar la solución. Recuerda, que no tiene por que estar igual tu solución con la del post, el objetivo es que aprendas no que me copies la solución.
Crea un proyecto en Java por ejercicio. Colocare en las soluciones algunos comentarios para que sean más fácilmente entendible.
Te recomiendo que uses mensajes de trazas, donde te sean necesarios. Si tienes problemas también puedes usar el depurador.
Aquí tienes todos los posts relacionados con Java:
Curso Java
Si tienes alguna duda, recuerda que puedes consultarnos escribiendo un comentario en este post o enviándonos un e-mail a administrador@discoduroderoer.es
Al final de los ejercicios, os dejamos el enlace para descargaros los proyectos.
IMPORTANTE: para realizar esta serie de ejercicios necesitáis usar listas enlazadas, ya este hecha por vosotros, la de java o la nuestra creada específicamente para ello.
Pincha aquí para descargar nuestra lista enlazada, incluye la clase ListaEnlazada y Nodo.
Tambien os dejo un par de métodos interesantes para crear números alreatorios, ya puesto en otro post.
/**
* Genera un numero aleatorio entre dos numeros.
* Entre el minimo y el maximo incluidos
* @param minimo Número mínimo
* @param maximo Número máximo
* @return Número entre minimo y maximo
*/
public static int generaNumeroAleatorio(int minimo, int maximo){
int num=(int)Math.floor(Math.random()*(minimo-(maximo+1))+(maximo+1));
return num;
}
/**
* Genera un numero aleatorio entre dos numeros reales.
* Entre el minimo y el maximo incluidos
* Devuelve un numero con dos decimales.
* @param minimo Número mínimo
* @param maximo Número máximo
* @return Número entre minimo y maximo
*/
public static double generaNumeroRealAleatorio(double minimo, double maximo){
double num=Math.rint(Math.floor(Math.random()*(minimo-((maximo*100)+1))+((maximo*100)+1)))/100;
return num;
}
1) Un cine de un pueblo pequeño nos propone hacer una aplicación para controlar las personas de una cola de un cine en los grandes estrenos de películas.
Un conjunto de personas esperaran la cola para sacar una entrada, tendremos que calcular la entrada según la edad de la persona (mínimo 5 años).
La edad de las personas se generan aleatoriamente entre 5 y 60 años. Os recomiendo realizar un método en el main para generar Personas en la cola.
Al final, deberemos mostrar la cantidad total recaudada. El número de personas de la cola se elige al azar entre 0 y 50.
Os dejo la clase Persona . Solo tenéis que hacer el main.
Pincha aquí para descargar la clase Persona.
Te recomiendo usar un mensaje de traza para saber si la recaudacion es correcta según la edad (opcional).
Recuerda que al final la lista debe quedar vacía, una vez que una persona paga su entrada ya no está en la cola.
Aquí os dejo la lista de precios:
| Edad | Precio |
| Entre 5 y 10 años | 1 € |
| Entre 11 y 17 años | 2.5 € |
| Mayor de 18 años | 3.5 € |
| Spoiler Inside |
SelectShow> |
–Clase Persona
/**
* @author DiscoDurodeRoer
*/
public class Persona {
private int edad;
/**
* Constructor por defecto
* @param edad
*/
public Persona(int edad){
this.edad=edad;
}
/**
* Devuelve la edad
* @return Edad acutal
*/
public int getEdad() {
return edad;
}
/**
* Modifica la edad
* @param edad Valor edad
*/
public void setEdad(int edad) {
this.edad = edad;
}
}
–Main
/**
* @author DiscoDurodeRoer
*/
public class CineApp {
public static void main(String[] args) {
//Creamos la cola, al crearla ya creamos el numero de personas
ListaEnlazada<Persona> cola = new ListaEnlazada<>();
//Generamos la cola
generarCola(cola);
//Creamos variables que nos seran útiles
double recaudacion;
double recaudacionTotal=0;
Persona espectadorActual;
int edadActual;
//Recorremos la cola
while(!cola.estaVacia()){
//"Atendemos" al espectador para que pague
espectadorActual=cola.devolverPrimero();
edadActual=espectadorActual.getEdad();
//Comprobamosla edad
if(edadActual>=5 && edadActual<=10){ recaudacion=1; }else if(edadActual>=11 && edadActual<=17){
recaudacion=2.5;
}else{
recaudacion=3.5;
}
recaudacionTotal+=recaudacion;
System.out.println("Una persona de "+edadActual+" años se le ha cobrado " +recaudacion+ " euros");
//Quitamos al espectador de la cola
//Tambien hemos podido usar al principio el meotodo devolverYBorrarPrimero();
cola.quitarPrimero();
}
//Mostramos el resultado
System.out.println("La recaudación es de "+recaudacionTotal+" euros");
}
/**
* Genera una cola de personas
* @param cola
*/
public static void generarCola(ListaEnlazada<Persona> cola){
int numeroPersonas=generaNumeroAleatorio(1,50);
for(int i=0;i<numeroPersonas;i++){
cola.insertarUltimo(new Persona(generaNumeroAleatorio(5, 60)));
}
}
/**
* Genera un numero aleatorio entre dos numeros.
* Entre el minimo y el maximo incluidos
* @param minimo Número mínimo
* @param maximo Número máximo
* @return Número entre minimo y maximo
*/
public static int generaNumeroAleatorio(int minimo, int maximo){
int num=(int)Math.floor(Math.random()*(minimo-(maximo+1))+(maximo+1));
return num;
}
}
|
2) Realiza el ejercicio anterior pero el lugar de usar una lista enlazada, usar la clase ArrayList. Usa un iterador para recorrer el ArrayList. Usa la misma clase Persona del ejercicio anterior.
| Spoiler Inside |
SelectShow> |
–Clase Persona
/**
* @author DiscoDurodeRoer
*/
public class Persona {
private int edad;
/**
* Constructor por defecto
* @param edad
*/
public Persona(int edad){
this.edad=edad;
}
/**
* Devuelve la edad
* @return Edad acutal
*/
public int getEdad() {
return edad;
}
/**
* Modifica la edad
* @param edad Valor edad
*/
public void setEdad(int edad) {
this.edad = edad;
}
}
–Main
import java.util.ArrayList;
import java.util.Iterator;
/**
* @author DiscoDurodeRoer
*/
public class CineApp {
public static void main(String[] args) {
//Creamos la cola, al crearla ya creamos el numero de personas
ArrayLis<Persona> cola = new ArrayList<>();
generarCola(cola);
//Creamos variables que nos seran útiles
double recaudacion;
double recaudacionTotal=0;
Persona espectadorActual;
int edadActual;
//Creamos el iterator
Iterator<Persona> it=cola.iterator();
//Recorremos la cola
while(it.hasNext()){
espectadorActual=it.next();
//"Atendemos" al espectador para que pague
edadActual=espectadorActual.getEdad();
//Comprobamosla edad
if(edadActual>=5 && edadActual<=10){ recaudacion=1; }else if(edadActual>=11 && edadActual<=17){
recaudacion=2.5;
}else{
recaudacion=3.5;
}
recaudacionTotal+=recaudacion;
System.out.println("Una persona de "+edadActual+" años se le ha cobrado " +recaudacion+ " euros");
}
//Mostramos el resultado
System.out.println("La recaudación es de "+recaudacionTotal+" euros");
}
public static void generarCola(ArrayList<Persona> cola){
int numeroPersonas=generaNumeroAleatorio(1,50);
for(int i=0;i<numeroPersonas;i++){
cola.add(new Persona(generaNumeroAleatorio(5, 60)));
}
}
/**
* Genera un numero aleatorio entre dos numeros.
* Entre el minimo y el maximo incluidos
* @param minimo Número mínimo
* @param maximo Número máximo
* @return Número entre minimo y maximo
*/
public static int generaNumeroAleatorio(int minimo, int maximo){
int num=(int)Math.floor(Math.random()*(minimo-(maximo+1))+(maximo+1));
return num;
}
}
|
3) Un supermercado nos pide que hagamos una pequeña aplicación que almacene los productos pasados por el escaner.
La aplicación debe almacenar Productos (clase), cada producto al crearse contiene una cantidad, un precio (estos dos generados aleatoriamente). El nombre del producto será básico (producto1, producto2, producto3, etc.).
Te dejo la clase Producto, solo agrégala a tu proyecto. Pincha aquí para descargarlo.
El precio ya viene con los impuestos incluidos.
Calcular el precio total de una lista de entre 1 y 8 productos (aleatorio). Mostrar un ticket con todo lo vendido y el precio final como se hacen en los supermercados. Más o menos con este formato, lo importante son los datos, no el estilo:
***********Cantidad****Precio*****Total
Producto1 5 3.5 17.5
Producto2 7 2.5 17.5
Precio final 35
| Spoiler Inside |
SelectShow> |
–Clase Producto
import java.text.DecimalFormat;
/**
* @author DiscoDurodeRoer
*/
public class Producto {
private int cantidad;
private double precio;
/**
* Constructor por defecto
* @param cantidad
* @param precio
*/
public Producto(int cantidad, double precio){
this.cantidad=cantidad;
this.precio=precio;
}
/**
* Devuelve la cantidad de productos
* @return Cantidad de producto
*/
public int getCantidad() {
return cantidad;
}
/**
* Devuelve el precio
* @return Precio del producto
*/
public double getPrecio() {
return precio;
}
/**
* Devuelve el precio final que tiene un producto
* @return precio final
*/
public double precioFinal(){
//Formateamos el precio final por problemas de precision
DecimalFormat df=new DecimalFormat("#,##");
return Double.parseDouble(df.format(this.precio * this.cantidad));
}
}
–Main
/**
* @author DiscoDurodeRoer
*/
public class SupermercadoApp {
public static void main(String[] args) {
//Creamos la lista de productos
ListaEnlazada<Producto> productos=new ListaEnlazada<>();
//Generamos los productos
generarProductos(productos);
//Declaramos variables que necesitaremos
String ticket="************Cantidad***Precio***Total\\n";
double precioTotal=0;
Producto productoActual;
//Recorremos la lista
for(int i=0;!productos.estaVacia();i++){
productoActual=productos.devolverYBorrarPrimero();
precioTotal+=productoActual.precioFinal();
ticket+="Producto"+(i+1)+"\\t"+productoActual.getCantidad()+
"\\t"+productoActual.getPrecio()+
"\\t"+productoActual.precioFinal()+"\\n";
}
ticket+="Precio final\\t\\t\\t"+precioTotal;
System.out.println(ticket);
}
/**
* Genera productos que se almacenan en la lista
* @param lista
*/
public static void generarProductos(ListaEnlazada<Producto> lista){
int numeroPersonas=generaNumeroAleatorio(1,8);
int cantidad;
double precio;
for(int i=0;i<numeroPersonas;i++){
cantidad=generaNumeroAleatorio(1,10);;
precio=generaNumeroRealAleatorio(0.05, 50);
lista.insertarUltimo(new Producto(cantidad, precio));
}
}
/**
* Genera un numero aleatorio entre dos numeros.
* Entre el minimo y el maximo incluidos
* @param minimo Número mínimo
* @param maximo Número máximo
* @return Número entre minimo y maximo
*/
public static int generaNumeroAleatorio(int minimo, int maximo){
int num=(int)Math.floor(Math.random()*(minimo-(maximo+1))+(maximo+1));
return num;
}
/**
* Genera un numero aleatorio entre dos numeros reales.
* Entre el minimo y el maximo incluidos
* Devuelve un numero con dos decimales.
* @param minimo Número mínimo
* @param maximo Número máximo
* @return Número entre minimo y maximo
*/
public static double generaNumeroRealAleatorio(double minimo, double maximo){
double num=Math.rint(Math.floor(Math.random()*(minimo-((maximo*100)+1))+((maximo*100)+1)))/100;
return num;
}
}
|
4) Realiza el ejercicio anterior pero el lugar de usar una lista enlazada, usar la clase ArrayList. Usa un iterador para recorrer el ArrayList.
| Spoiler Inside |
SelectShow> |
–Clase Producto
import java.text.DecimalFormat;
/**
* @author DiscoDurodeRoer
*/
public class Producto {
private int cantidad;
private double precio;
/**
* Constructor por defecto
* @param cantidad
* @param precio
*/
public Producto(int cantidad, double precio){
this.cantidad=cantidad;
this.precio=precio;
}
/**
* Devuelve la cantidad de productos
* @return Cantidad de producto
*/
public int getCantidad() {
return cantidad;
}
/**
* Devuelve el precio
* @return Precio del producto
*/
public double getPrecio() {
return precio;
}
/**
* Devuelve el precio final que tiene un producto
* @return precio final
*/
public double precioFinal(){
//Formateamos el precio final por problemas de precision
DecimalFormat df=new DecimalFormat("#,##");
return Double.parseDouble(df.format(this.precio * this.cantidad));
}
}
—Main
import java.util.ArrayList;
import java.util.Iterator;
/**
* @author DiscoDurodeRoer
*/
public class SupermercadoApp {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
//Creamos la lista de productos
ArrayList<Producto> productos=new ArrayList<>();
//Generamos la cola
generarProductos(productos);
//Declaramos variables que necesitaremos
String ticket="************Cantidad***Precio***Total\\n";
double precioTotal=0;
Producto productoActual;
Iterator<Producto> it=productos.iterator();
//Recorremos la lista
for(int i=0;it.hasNext();i++){
productoActual= it.next();
precioTotal+=productoActual.precioFinal();
ticket+="Producto"+(i+1)+"\\t"+productoActual.getCantidad()
+"\\t"+productoActual.getPrecio()
+"\\t"+productoActual.precioFinal()+"\\n";
}
ticket+="Precio final\\t\\t\\t"+precioTotal;
System.out.println(ticket);
}
/**
* Genera productos que se almacenan en la lista
* @param lista
*/
public static void generarProductos(ArrayList<Producto> lista){
int numeroPersonas=generaNumeroAleatorio(1,8);
int cantidad;
double precio;
for(int i=0;i<numeroPersonas;i++){
cantidad=generaNumeroAleatorio(1,10);
precio=generaNumeroRealAleatorio(0.05, 50);
lista.add(new Producto(cantidad, precio));
}
}
/**
* Genera un numero aleatorio entre dos numeros.
* Entre el minimo y el maximo incluidos
* @param minimo Número mínimo
* @param maximo Número máximo
* @return Número entre minimo y maximo
*/
public static int generaNumeroAleatorio(int minimo, int maximo){
int num=(int)Math.floor(Math.random()*(minimo-(maximo+1))+(maximo+1));
return num;
}
/**
* Genera un numero aleatorio entre dos numeros reales.
* Entre el minimo y el maximo incluidos
* Devuelve un numero con dos decimales.
* @param minimo Número mínimo
* @param maximo Número máximo
* @return Número entre minimo y maximo
*/
public static double generaNumeroRealAleatorio(double minimo, double maximo){
double num=Math.rint(Math.floor(Math.random()*(minimo-((maximo*100)+1))+((maximo*100)+1)))/100;
return num;
}
}
|
5) Un amigo funcionario nos pide que le hagamos un informe para sus informes. Debemos gestionar informes que están formados de un código numérico y una tarea que pueden ser ADMINISTRATIVO, EMPRESARIAL y PERSONAL. Debe comprobarse que la tarea es alguna de estas.
Nuestro amigo quiere que seamos capaz de agregar y eliminar informes en forma de pila (el último en entrar, es el primero en salir). Agrega 10 informes y muestra su contenido, elimina todo el contenido y agrega de nuevo 5 informes.
Puedes crear los informes como quieras.
Te dejo la clase Informe como apoyo. Pîncha aquí para descargar la clase.
| Spoiler Inside |
SelectShow> |
— Informe
public class Informe {
public final String[] tareas={"administrativo", "empresarial", "personal"};
private int codigo;
private String tarea;
public Informe(int codigo,int indiceTarea){
this.codigo= codigo;
this.tarea= this.tareas[indiceTarea];
}
public int getCodigo() {
return codigo;
}
public void setCodigo(int codigo) {
this.codigo = codigo;
}
public String getTarea() {
return tarea;
}
public void setTarea(String tarea) {
this.tarea = tarea;
}
public String[] getTareas(){
return tareas;
}
@Override
public String toString(){
return "El informe con codigo "+codigo+" tiene la tarea de "+tarea;
}
}
— InformeApp
/**
* @author DiscoDurodeRoer
*/
public class InformeApp {
public static void main(String[] args) {
ListaEnlazada<Informe> informes=new ListaEnlazada<>();
//Agregamos 10 informes
for(int i=1;<=10;i++){
//Genero los informes
informes.insertarUltimo(new Informe(i, generaNumeroAleatorio(0,2)));
}
System.out.println("Primeros diez informes agregados: ");
//Mostramos los ultimos informes
ListaEnlazada<Informe> aux=new ListaEnlazada<>();
//Paso los datos en una lista llamado aux
while(!informes.estaVacia()){
aux.insertarUltimo(informes.devolverUltimo());
informes.quitarUltimo();
System.out.println(aux.devolverUltimo());
}
informes = aux;
//Los eliminamos todos, uno a uno
while(!informes.estaVacia()){
informes.quitarUltimo();
}
System.out.println("Informes eliminados");
//Agregamos 5 informes mas
for(int i=1;i<=5;i++){
//Genero los informes
informes.insertarUltimo(new Informe(i, generaNumeroAleatorio(0,2)));
}
System.out.println("Agregados 5 informes");
//Mostramos los ultimos informes
aux=new ListaEnlazada<>();
while(!informes.estaVacia()){
aux.insertarUltimo(informes.devolverUltimo());
informes.quitarUltimo();
System.out.println(aux.devolverUltimo());
}
//Dejamos informes con los datos de aux;
informes = aux;
aux=null; //La dejamos sin referenciar
}
/**
* Genera un numero aleatorio entre dos numeros.
* Entre el minimo y el maximo incluidos
* @param minimo Número mínimo
* @param maximo Número máximo
* @return Número entre minimo y maximo
*/
public static int generaNumeroAleatorio(int minimo, int maximo){
int num=(int)Math.floor(Math.random()*(minimo-(maximo+1))+(maximo+1));
return num;
}
}
|
Aquí os dejo todos los proyectos. Descargalo aquí.
Espero que os sea de ayuda. Si tenéis dudas, preguntad, estamos para ayudarte.
Gracias por amigo po el aporte, me ayudo mucho para comprender la logica
Hola tio , eres muy bueno en esto , disculpa mi pregunta es la siguiente:
Que ps te ha faltado implementar algunos por no decir la mayoría de los métodos en la clase Lista , que ps eso como que me os confunde¡ , seguro tu lo sobreentiendes que se hace, pero pero para los primeros que se estan forjando en el mundo de los procesamiento de Datos , se les complica un poco ¡¡
Hay muchos métodos creados ademas de estar comentado y tienes ejemplos en la pagina donde se descarga la lista Enlazada.
¿A que metodos te refieres?
«Por favor ayudame con este ejercicio»: se tiene tres ensambladoras de carros que produce tres modelos de vehículos a,b,c así como también los costos asociados a cada modelo se desea a)construir un arreglo que represente las ensambladoras y modelos
b)construir el arreglo que representa la relacion de los modelos y los costos
c)obtener los costos asociados a cada ensambladora para producir vehiculos
d)total de costos generales
Hola chicos , gracias de antemano por estos ejercicios , pero en el 2º me da un error el metodo generaNumeroealAleatorio , me da una excepcion de tipo NumberFormatException
Perdona , donde me da el error es en el metodo PrecioFinal en la multiplicacion entre precio y cantidad..
no quierp
Crear una lista doblemente enlazada con 50 números enteros, del 1 al 999 generados aleatoriamente. Una vez creada la lista, se deben eliminar los nodos que estén fuera de un rango de valores leídos desde el teclado.
La empresa “te ensamblo tu cochecito”. Se dedica al ensamblaje de coches de juguete, los cuales tienen cuatro componentes: carrocería, motor, ruedas y adorno, teniendo asignados los códigos, 1, 2, 3 y 4 respectivamente. Para ensamblar un coche de juguete se precisa de una carrocería, un motor, cuatro ruedas y dos adornos.
Estos componentes son de fabricación externa y se adquieren a una serie de proveedores que aplican dos tipos de descuentos por volumen de compras.
El descuento 1 se aplica a las unidades comprendidas entre 501 y 999
a partir de la unidad 1000, se aplicará el segundo tipo de descuento (las primeras 500 unidades no disfrutan de ningún tipo de descuento).
· El descuento 1 es de un 10% de su precio para las carrocerías, de un 13% para los motores, 15% para las ruedas y 5% en el caso de los adornos.
· El descuento 2 es de un 20% de su precio para las carrocerías, de un 20% para los motores, 25% para las ruedas y 10% en el caso de los adornos.
El precio de las carrocerías es de 2.500., los motores se venden a 3.000 ., a 500. cada una de las ruedas y a 200. los adornos.
La demanda de coches de juguete que se espera en cada uno de los meses del año es la expuesta en la Tabla.1 Todos los meses del año se atiende por entero la demanda y sólo se fabrica cada mes para cubrir ésta, no considerándose la posibilidad de crear stocks de seguridad.
Se desea elaborar un programa, en la que se obtenga la valor del descuento que se aplicará cada mes en cada componente, así como el precio bruto de cada uno (precio sin el descuento correspondiente), y el precio neto, una vez descontado el descuento correspondiente. También se desea obtener, para el total de coches, los descuentos, precios brutos y precios netos totales.
Demanda
Enero
1200
Febrero
900
Marzo
800
Abril
450
Mayo
600
Junio
400
Julio
350
Agosto
500
Septiembre
800
Octubre
900
Noviembre
1000
Diciembre
1700
los paquetes de estos ejercicios no me los descargan