Java - se requiere una estructura de datos que almacene los productos de la tienda

 
Vista:

se requiere una estructura de datos que almacene los productos de la tienda

Publicado por brayan (1 intervención) el 23/05/2019 17:56:54
se requiere una estructura de datos que almacene los productos de la tienda y que le permita hacer las siguientes tareas:


a. Le permita elegir al usuario si desea ingresar los productos o no
b. Permitir el ingreso de que mes desea hacer el ingreso del producto sabiendo que el año contiene 12 meses
c. Guardar los productos de un almacén, tales como su nombre, código, precio, fecha de ingreso, fecha de vencimiento de manera mensual durante un año
d. Se necesita conocer si el producto esta vencido o no
e. Se requiere conocer cuál fue el último producto ingresado y cuál fue el primero
f. Se requiere conocer cuál es el producto más costoso
g. Se requiere conocer la cantidad de productos ingresados
h. Se requiere conocer el costo total de los productos del almacén
i. Se requiere conocer el promedio de precios
j. Imprimir productos ingresados por mes
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Omar
Val: 77
Ha disminuido su posición en 8 puestos en Java (en relación al último mes)
Gráfica de Java

se requiere una estructura de datos que almacene los productos de la tienda

Publicado por Omar (24 intervenciones) el 23/05/2019 18:17:40
Brayan, de donde eres? te me haces conocido....XD
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Billy Joel
Val: 2.665
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

[Solución] se requiere una estructura de datos que almacene los productos de la tienda

Publicado por Billy Joel (795 intervenciones) el 23/05/2019 23:14:06
El punto a lo debe resolver el programa principal.
El punto d sería una propiedad del producto.
Entonces necesitamos crear un bean para representar a los productos:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
import java.util.Calendar;
import java.util.Date;
 
/**
 * Esta clase representa un producto de la tienda
 *
 * @author billy.johnson
 */
public class Producto {
 
    private String nombre;
    private String codigo;
    private Double precio;
    private Date fechaIngreso;
    private Date fechaVencimiento;
    private boolean vencido;
 
    /**
     * @return the nombre
     */
    public String getNombre() {
        return nombre;
    }
 
    /**
     * @param nombre the nombre to set
     */
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
 
    /**
     * @return the codigo
     */
    public String getCodigo() {
        return codigo;
    }
 
    /**
     * @param codigo the codigo to set
     */
    public void setCodigo(String codigo) {
        this.codigo = codigo;
    }
 
    /**
     * @return the precio
     */
    public Double getPrecio() {
        return precio;
    }
 
    /**
     * @param precio the precio to set
     */
    public void setPrecio(Double precio) {
        this.precio = precio;
    }
 
    /**
     * @return the fechaIngreso
     */
    public Date getFechaIngreso() {
        return fechaIngreso;
    }
 
    /**
     * @param fechaIngreso the fechaIngreso to set
     */
    public void setFechaIngreso(Date fechaIngreso) {
        this.fechaIngreso = fechaIngreso;
    }
 
    /**
     * @return the fechaVencimiento
     */
    public Date getFechaVencimiento() {
        return fechaVencimiento;
    }
 
    /**
     * @param fechaVencimiento the fechaVencimiento to set
     */
    public void setFechaVencimiento(Date fechaVencimiento) {
        this.fechaVencimiento = fechaVencimiento;
        vencido = Calendar.getInstance().getTime().after(fechaVencimiento);
    }
 
    /**
     * @return the vencido
     */
    public boolean isVencido() {
        if (!vencido && fechaVencimiento != null && Calendar.getInstance().getTime().after(fechaVencimiento)) {
            vencido = true;
        }
        return vencido;
    }
}

Presta atención a los métodos setFechaVencimiento y isVencido. Estos métodos se utilizan para establecer el valor de la propiedad vencido.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Billy Joel
Val: 2.665
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

[Solución] se requiere una estructura de datos que almacene los productos de la tienda

Publicado por Billy Joel (795 intervenciones) el 23/05/2019 23:52:34
Entonces la estructura de datos... digamos controlador para gestionar productos creamos la clase GestionProductos.

Entonces para el punto b y c he creado el método sobre cargado registrarProducto que recibe los siguientes parámetros:

Integer mes
String nombre
String codigo
Double precio
String fechaVencimiento la fecha debe tener este formato yyyy/mmm/dd
String fechaIngreso (opcional) la fecha debe tener este formato yyyy/mmm/dd

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
/**
 * Registra un nuevo producto con la fecha actual como fecha de ingreso
 *
 * @param mes
 * @param nombre
 * @param codigo
 * @param precio
 * @param fechaVencimiento la fecha debe tener este formato yyyy/mmm/dd
 * @return
 */
public Producto registrarProducto(Integer mes, String nombre, String codigo, Double precio, String fechaVencimiento) {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
    return registrarProducto(mes, nombre, codigo, precio, fechaVencimiento, sdf.format(Calendar.getInstance().getTime()));
}
 
/**
 * Registra un nuevo producto
 *
 * @param mes
 * @param nombre
 * @param codigo
 * @param precio
 * @param fechaVencimiento la fecha debe tener este formato yyyy/mmm/dd
 * @param fechaIngreso la fecha debe tener este formato yyyy/mmm/dd
 * @return
 */
public Producto registrarProducto(Integer mes, String nombre, String codigo, Double precio, String fechaVencimiento, String fechaIngreso) {
    if (mes < 1 || mes > 12) {
        return null;
    } else {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        Producto p = new Producto();
        try {
            p.setNombre(nombre);
            p.setCodigo(codigo);
            p.setPrecio(precio);
            p.setFechaIngreso(sdf.parse(fechaIngreso));
            p.setFechaVencimiento(sdf.parse(fechaVencimiento));
            productos.add(p);
            if (productosMes.containsKey(mes)) {
                productosMes.get(mes).add(p);
            } else {
                List<Producto> pp = new ArrayList();
                pp.add(p);
                productosMes.put(mes, pp);
            }
            if (productos.size() == 1) {
                productoMasCostoso = p;
            } else {
                setProductoMasCostoso();
            }
            System.out.println("Producto agregado");
        } catch (ParseException ex) {
            System.out.println("ERROR: formato de fecha incorrecto");
            return null;
        }
        return p;
    }
}

Para los punto d y e como se trata de saber si alguno de los productos está vencido o no. Simplemente preguntamos por el método isVencido()
Ejemplo:
1
GestionProductos.getInstance().getPrimerProducto().isVencido();
1
GestionProductos.getInstance().getUltimoProducto().isVencido();

Punto f getProductoMasCostoso
1
GestionProductos.getInstance().getProductoMasCostoso();

Punto g getProductosCount
1
GestionProductos.getInstance().getProductosCount();

Punto h getCostoTotal
1
GestionProductos.getInstance().getCostoTotal();

Punto i getPromedioPrecios
1
GestionProductos.getInstance().getPromedioPrecios();

Punto j imprimirProductosPorMes
1
GestionProductos.getInstance().imprimirProductosPorMes();
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Billy Joel
Val: 2.665
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

[Solución] se requiere una estructura de datos que almacene los productos de la tienda

Publicado por Billy Joel (795 intervenciones) el 23/05/2019 23:54:54
Acá está la clase GestionProductos completa
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
 
/**
 * Esta clase nos ayuda a gestionar los productos de la tienda. Para invocar a
 * esta clase se debe utilizar el método getInstance
 * <code>GestionProductos.getInstance()</code> a partir de ahí se puede utilizar
 * los métodos que contiene la clase
 *
 * @author billy.johnson
 */
public class GestionProductos {
 
    LinkedList<Producto> productos;
    Map<Integer, List<Producto>> productosMes;
    private Producto productoMasCostoso;
 
    private static GestionProductos gestion = null;
 
    public static final Integer ENERO = 1;
    public static final Integer FEBRERO = 2;
    public static final Integer MARZO = 3;
    public static final Integer ABRIL = 4;
    public static final Integer MAYO = 5;
    public static final Integer JUNIO = 6;
    public static final Integer JULIO = 7;
    public static final Integer AGOSTO = 8;
    public static final Integer SEPTIEMBRE = 9;
    public static final Integer OCTUBRE = 10;
    public static final Integer NOVIEMBRE = 11;
    public static final Integer DICIEMBRE = 12;
 
    /**
     * Constructor de la clase
     */
    private GestionProductos() {
        productos = new LinkedList();
        productosMes = new HashMap();
    }
 
    /**
     * Devuelve una instancia de la clase
     *
     * @return
     */
    public static GestionProductos getInstance() {
        if (gestion == null) {
            gestion = new GestionProductos();
        }
        return gestion;
    }
 
    /**
     * Registra un nuevo producto con la fecha actual como fecha de ingreso
     *
     * @param mes
     * @param nombre
     * @param codigo
     * @param precio
     * @param fechaVencimiento la fecha debe tener este formato yyyy/mmm/dd
     * @return
     */
    public Producto registrarProducto(Integer mes, String nombre, String codigo, Double precio, String fechaVencimiento) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        return registrarProducto(mes, nombre, codigo, precio, fechaVencimiento, sdf.format(Calendar.getInstance().getTime()));
    }
 
    /**
     * Registra un nuevo producto
     *
     * @param mes
     * @param nombre
     * @param codigo
     * @param precio
     * @param fechaVencimiento la fecha debe tener este formato yyyy/mmm/dd
     * @param fechaIngreso la fecha debe tener este formato yyyy/mmm/dd
     * @return
     */
    public Producto registrarProducto(Integer mes, String nombre, String codigo, Double precio, String fechaVencimiento, String fechaIngreso) {
        if (mes < 1 || mes > 12) {
            return null;
        } else {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
            Producto p = new Producto();
            try {
                p.setNombre(nombre);
                p.setCodigo(codigo);
                p.setPrecio(precio);
                p.setFechaIngreso(sdf.parse(fechaIngreso));
                p.setFechaVencimiento(sdf.parse(fechaVencimiento));
                productos.add(p);
                if (productosMes.containsKey(mes)) {
                    productosMes.get(mes).add(p);
                } else {
                    List<Producto> pp = new ArrayList();
                    pp.add(p);
                    productosMes.put(mes, pp);
                }
                if (productos.size() == 1) {
                    productoMasCostoso = p;
                } else {
                    setProductoMasCostoso();
                }
                System.out.println("Producto agregado");
            } catch (ParseException ex) {
                System.out.println("ERROR: formato de fecha incorrecto");
                return null;
            }
            return p;
        }
    }
 
    /**
     * Devuelve el primer producto de los ingresados
     *
     * @return
     */
    public Producto getPrimerProducto() {
        if (productos.isEmpty()) {
            return null;
        } else {
            return productos.getFirst();
        }
    }
 
    /**
     * Devuelve el último producto de los ingresados
     *
     * @return
     */
    public Producto getUltimoProducto() {
        if (productos.isEmpty()) {
            return null;
        } else {
            return productos.getLast();
        }
    }
 
    /**
     * @return the productoMasCostoso
     */
    public Producto getProductoMasCostoso() {
        return productoMasCostoso;
    }
 
    private void setProductoMasCostoso() {
//        for(Producto p : productos){
//            if(p.getPrecio() > productoMasCostoso.getPrecio()){
//                productoMasCostoso = p;
//            }
//        }
        productos.stream().filter((p) -> (p.getPrecio() > productoMasCostoso.getPrecio())).forEachOrdered((p) -> {
            productoMasCostoso = p;
        });
    }
 
    /**
     * Devuelve la cantidad de productos ingresados
     *
     * @return
     */
    public Integer getProductosCount() {
        return productos.size();
    }
 
    /**
     * Devuelve la sumatoria de precios los productos que no están vencidos
     *
     * @return
     */
    public Double getCostoTotal() {
        Double total = 0.0;
//        for (Producto p : productos) {
//            if (!p.isVencido()) {
//                total += p.getPrecio();
//            }
//        }
        total = productos.stream().filter((p) -> (!p.isVencido())).map((p) -> p.getPrecio()).reduce(total, (accumulator, _item) -> accumulator + _item);
        return total;
    }
 
    /**
     * Devuelve el promedio de precios de los productos que no estén vencidos
     *
     * @return
     */
    public Double getPromedioPrecios() {
        int count = 0;
//        for (Producto p : productos) {
//            if (!p.isVencido()) {
//                count++;
//            }
//        }
        count = productos.stream().filter((p) -> (!p.isVencido())).map((_item) -> 1).reduce(count, Integer::sum);
        return getCostoTotal() / count;
    }
 
    /**
     * Imprimir productos ingresados por mes
     */
    public void imprimirProductosPorMes() {
        SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
        String[] meses = {
            "ENERO",
            "FEBRERO",
            "MARZO",
            "MAYO",
            "ABRIL",
            "JUNIO",
            "JULIO",
            "AGOSTO",
            "SEPTIEMBRE",
            "OCTUBRE",
            "NOVIEMBRE",
            "DICIEMBRE"
        };
        for (int i = 1; i <= meses.length; i++) {
            if (productosMes.containsKey(i)) {
                System.out.println("Mes " + meses[i] + ":");
                productosMes.get(i - 1).forEach(p -> {
                    System.out.println(
                            "Codigo: " + p.getCodigo()
                            + "\nNombre: " + p.getNombre()
                            + "\nPrecio: " + p.getPrecio()
                            + "\nFecha de ingreso: " + sdf.format(p.getFechaIngreso())
                            + "\nFecha de vencimiento: " + sdf.format(p.getFechaVencimiento())
                            + "\nVencido: " + (p.isVencido() ? "Si" : "No") + "\n"
                    );
                });
                System.out.println("------------------------------------------\n");
            }
        }
    }
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
sin imagen de perfil
Val: 973
Bronce
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

[Solución] se requiere una estructura de datos que almacene los productos de la tienda

Publicado por Agustin (146 intervenciones) el 25/05/2019 22:31:46
Por Dios que lenguaje horrendo. Acá tenes exactamente la misma funcionalidad, implementada en un lenguaje decente.

92 líneas de codigo total, contra 339 (!!!!) en java, a razon de 3.6 a 1.
Si eliminamos los comentarios, tu versión de java son 233 lineas total, a razón de 2.5 a 1.

Ni hablar de que mi código es infinitamente más prolijo y legible. Encima mi código es mejor, ya que tiene más validaciones, por ejemplo en el caso del precio promedio, que tu código falla si no existiera ningun producto que no esté vencido, ya que hacés una división por cero.

Todo esto comprueba mi afirmación de que cualquier cosa hecha en java requiere 3 veces la cantidad de código y por ende de esfuerzo que hacerlo con cualquier lenguaje decente y usable.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
-2
Comentar