Clase Vector api Java lista sincronizada útil en entornos concurrentes CU00922C

[Pepote21]

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.

Código: [Seleccionar]

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";
    }
   
}

Código: [Seleccionar]

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);
            }         
        }
    }   
}

[Pepote21]

Hola otra vez. He hecho un nuevo código sobre el ejercicio que os paso. La clase Paquete es la misma.
Gracias

Código: [Seleccionar]

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");
    }
}

Código: [Seleccionar]

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();
    }
}

[fmartinez25]

Hola.

Me gusta tu solución, pero yo lo he implementado de otra manera:

Clase Paquete

Código: [Seleccionar]

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

Código: [Seleccionar]

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");       
    }   
}


[Pepote21]

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.