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 07 de Noviembre 2017, 16:12
-
Hola a todos. Os paso mi código del ejercicio CU00922C del tutorial pdf de programación avanzada Java de aprenderaprogramar. Gracias a todos. Un saludo.
public class Paquete {
private int idPaquete;
private int pesoPaquete;
public Paquete(){
idPaquete=0;
pesoPaquete=0;
}
public Paquete(int idPaquete,int pesoPaquete){
this.idPaquete=idPaquete;
this.pesoPaquete=pesoPaquete;
}
public int getIdPaquete() {
return idPaquete;
}
public void setIdPaquete(int idPaquete) {
this.idPaquete = idPaquete;
}
public int getPesoPaquete() {
return pesoPaquete;
}
public void setPesoPaquete(int pesoPaquete) {
this.pesoPaquete = pesoPaquete;
}
@Override
public String toString() {
return "Paquete{" + "idPaquete=" + idPaquete + ", pesoPaquete=" + pesoPaquete + '}'+"\n";
}
}import java.util.Iterator;
import java.util.Random;
import java.util.Vector;
/**
* Ejercicio CU00922C aprenderaprogramar.com
* Interfaz list, clase VECTOR
* Recorrer contenedor de paquetes al que se le añaden paquetes
*
* @author pepote21
* @version 20171107
*/
public class Principal {
public static void main(String[] args){
Vector<Paquete> v=new Vector(5,1);//Contenedor con capacidad de 5 paquetes
System.out.println("Capacidad inicial del contenedor: "+v.capacity()+" paquetes.");
int cargaMaximaContenedor=v.capacity()*100;
System.out.println("Capacidad máxima del contenedor: "+cargaMaximaContenedor+" kgs.");
Random rnd=new Random();
Paquete p=new Paquete();
int pesoTotal=0;
for(int i=0;i<50;i++){
p.setPesoPaquete(rnd.nextInt(71)+80);//Aleatoriamente se establece el peso de cada paquete
pesoTotal=p.getPesoPaquete()+pesoTotal;//Peso total contenedor
v.add(p); //Añadimos 50 paquetes al contenedor
}
System.out.println("Capacidad actual del contenedor: "+v.capacity());
cargaMaximaContenedor=v.capacity()*100;
pesoTotal=0;
Iterator<Paquete> it=v.iterator();
while(it.hasNext()){
Paquete tmp=it.next();
pesoTotal=tmp.getPesoPaquete()+pesoTotal;
}
String msg=("Un contenedor con capacidad para "+v.capacity()+" paquetes podría cargar "+
cargaMaximaContenedor+" y tenemos "+v.capacity()+" paquetes con un peso total de: "+pesoTotal);
String msg3=(". No ha sido necesario aumentar la capacidad");
if(pesoTotal<cargaMaximaContenedor){
System.out.println(msg+msg3);
}
while(pesoTotal>cargaMaximaContenedor){
v.ensureCapacity(v.capacity()+1);//ampliar la capacidad
cargaMaximaContenedor=v.capacity()*100;
if(pesoTotal<=cargaMaximaContenedor){
String msg2=(". Se ha aumentado la capacidad a "+v.capacity()+"\n paquetes lo que permite cargar hasta "+
cargaMaximaContenedor+" kilos");
System.out.println(msg+msg2);
}
}
}
}
-
Hola otra vez. He hecho un nuevo código sobre el ejercicio que os paso. La clase Paquete es la misma.
Gracias
import java.util.Iterator;
import java.util.Random;
import java.util.Vector;
import practicas.avanzadas.t922C.ejercicio.Paquete;
/**
*
* @author pepote21
*/
public class ContenedorApr2 {
private Vector<Paquete> contenedor;
private int capacidadPaquetes;
private int incrementoPaquetes;
private int pesoMaximoContenedor;
private int cargaMaximaContenedor;
private int pesoTotalPaquetes;
public ContenedorApr2(){//Constructor 1
contenedor=new Vector<Paquete>();
capacidadPaquetes=0;
incrementoPaquetes=0;
pesoMaximoContenedor=100;
cargaMaximaContenedor=0;
pesoTotalPaquetes=0;
}
public ContenedorApr2(int capacidad,int incremento,int pesoMaximoContenedor){//Constructor 2
contenedor=new Vector<Paquete>();
this.capacidadPaquetes=capacidad;
this.incrementoPaquetes=incremento;
this.pesoMaximoContenedor=pesoMaximoContenedor;
}
public void addPaquete(Paquete paquete){contenedor.add(paquete);}
public Vector<Paquete> getContenedor(){return contenedor;}
public void setPesoMaximoContenedor(int pesoMaximoContenedor){this.pesoMaximoContenedor=pesoMaximoContenedor;}
public int getPesoMaximoContenedor(){return pesoMaximoContenedor;}
public void setCargaMaximaContenedor(int cargaMaximaContenedor){this.cargaMaximaContenedor=cargaMaximaContenedor;}
public int getCargaMaximaContenedor(){return cargaMaximaContenedor;}
public void setCapacityContenedor(int capacidadPaquetes){this.capacidadPaquetes=capacidadPaquetes;}
public int getCapacityContenedor(){return capacidadPaquetes;}
public void setPesoTotalPaquetes(int pesoTotalPaquetes){this.pesoTotalPaquetes=pesoTotalPaquetes;}
public int getPesoTotalPaquetes(){return pesoTotalPaquetes;}
public void addPaquetes(int numPaquetes){
Random rnd=new Random();
for(int i=1;i<=numPaquetes;i++){
Paquete p=new Paquete(i,rnd.nextInt(71)+80);
contenedor.add(p);
setCapacityContenedor(i);//Número paquetes
capacidadPaquetes=getCapacityContenedor();
pesoTotalPaquetes=p.getPesoPaquete()+pesoTotalPaquetes;
}
}
public void determinarEstadoContenedor(){
Iterator<Paquete> it=contenedor.iterator();//Recorrer y listar con iterator
while(it.hasNext()){
Paquete tmp=it.next();
}
String msg=("Un contenedor con capacidad para "+capacidadPaquetes+" paquetes podría cargar "+
cargaMaximaContenedor+" kilos y tenemos "+capacidadPaquetes+" paquetes con un peso total de: "+
pesoTotalPaquetes+" kilos");
String msg3=(". No ha sido necesario aumentar la capacidad");
if(pesoTotalPaquetes<cargaMaximaContenedor){
System.out.println(msg+msg3);
}else{
while(pesoTotalPaquetes>cargaMaximaContenedor){
capacidadPaquetes++;
cargaMaximaContenedor=capacidadPaquetes*100;
}
if(pesoTotalPaquetes<=cargaMaximaContenedor){
String msg2=(". Se ha aumentado la capacidad a "+capacidadPaquetes+
"\n paquetes lo que permite cargar hasta "+pesoTotalPaquetes+" kilos");
System.out.println(msg+msg2);
}
}
}
public void mostrarDatosContenedor(){
capacidadPaquetes=getCapacityContenedor();
pesoMaximoContenedor=getPesoMaximoContenedor();
setCargaMaximaContenedor(capacidadPaquetes*pesoMaximoContenedor);
cargaMaximaContenedor=getCargaMaximaContenedor();
System.out.println("CAPACIDAD DEL CONTENEDOR: \nNúmero de paquetes: "+capacidadPaquetes+
"\nPeso Máximo contenedor: "+pesoMaximoContenedor+"\nCarga máxima contenedor: "+cargaMaximaContenedor+
"\nPeso total de los paquetes: "+pesoTotalPaquetes+"\n");
}
}
public class Principal {
public static void main(String[]args){
ContenedorApr2 c=new ContenedorApr2(5,1,100);
Paquete p=new Paquete();
c.mostrarDatosContenedor();
c.addPaquetes(50);
c.mostrarDatosContenedor();
c.determinarEstadoContenedor();
}
}
-
Hola.
Me gusta tu solución, pero yo lo he implementado de otra manera:
Clase Paquete
public class Paquete {
private int idPaquete;
private int pesoPaquete;
//Constructor
public Paquete(int idPaquete, int pesoPaquete){
this.idPaquete=idPaquete;
this.pesoPaquete=pesoPaquete;
}
//Métodos
public void setId(int id){idPaquete=id;}
public void setPeso(int peso){pesoPaquete=peso;}
public int getId(){return idPaquete;}
public int getPeso(){return pesoPaquete;}
@Override
public String toString(){
return "Paquete-> ID: "+idPaquete+", Peso: "+pesoPaquete+" kg";
}
}
Clase Principal
package cu00922c.ejercicio.vector;
import java.util.List;
import java.util.Random;
import java.util.Vector;
public class CU00922CEjercicio {
public static void main(String[] args) {
Vector<Paquete> contenedor = new Vector<>(5,1);//Creamos un vector de paquetes llamado contenedor
int cargaMaximaContenedor;
int carga;
carga = cargarContenedor(contenedor,50);//Cargamos el contenedor con 50 paquetes
cargaMaximaContenedor=contenedor.capacity()*100;
System.out.println("Un contenedor con "+contenedor.capacity()+" paquetes podría cargar "
+contenedor.capacity()*100+" kilos y tenemos "+contenedor.capacity()
+ " paquetes con un peso total de: "+ carga+" kilos");
//Aumentar la capacidad para poder contener la carga de los paquetes que tiene
if (carga>cargaMaximaContenedor){ aumentarCapacidad(contenedor,carga); }
else{System.out.println("No ha sido necesario aumentar la capacidad");}
}
//Cargar contenedor. Devuelve la carga del contenedor
private static int cargarContenedor(Vector<Paquete> contenedor, int paquetes){
int carga=0;
Random rnd = new Random();
for (int i=1;i<=paquetes;i++){
int peso=rnd.nextInt(70)+81;
contenedor.add(i-1, new Paquete(i,peso));
carga=carga+peso;
}
return carga;
}
//Aumenta la capacidad del contenedor
private static void aumentarCapacidad(Vector<Paquete> contenedor, int carga){
int resultado=carga/100;
if (carga%100>0){resultado++;}
contenedor.ensureCapacity(resultado);
System.out.println("Se ha aumentado la capacidad a "+contenedor.capacity()
+" paquetes, lo que permite cargar hasta "+contenedor.capacity()*100+" kilos");
}
}
-
Hola fmartinez25.
Me alegro. Aunque he visto un pequeño error al final del mío, que en su día no me dí cuenta.
Con respecto a tus códigos, también me gustan y te sigo.
Un saludo.