Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Java » vectores paralelos

Java - vectores paralelos

Volver
Nuevo Tema
<<>>
 
Vista:
Imágen de perfil de hernan
Val: 8
Ha aumentado su posición en 4 puestos en Java (en relación al último mes)
Gráfica de Java

vectores paralelos

Publicado por hernan (6 intervenciones) el 11/06/2019 08:23:05
hola necesito ayuda con este ejercicio no importa cuanto intento no ne sale bien es frustran te


Se desea utilizar vectores en paralelo para almacenar información de una serie de productos:
(0) (1) (2) (3) (4)
vector (1232) (2213) (3812) (4115) (3214)

vector (leche) (azúcar) (aceite) (huevos) (carne)

vector(2500) (1400) (5000) (500) (6500)

vector(20) (5) (8) (30) (10)
La información debe ser registrada directamente en la interfaz sin pedir la cantidad de elementos a ingresar.

ingreso de orden de compra

ítem comprado ( )
nombre del producto ( )
cantidad del producto ( )
(agregar) (finalizar)

El ítem comprado, realizará cuenta automática del número de productos que se hayan ingresado hasta el momento.
En el ComboBox, se selecciona el producto a comprar:
El desarrollador debe predeterminar 10 productos con su respectivo precio unitario.
Se ingresarán entonces N productos en Agregar hasta que el usuario haga clic en Finalizar, momento en el que se generarán los siguientes reportes:
- Producto con mayor y menor cantidad vendida
- Total en dinero de la venta en general
- Porcentaje que representó la venta de cada producto con respecto al total de la venta
- Generar un nuevo vector de tamaño N que almacene el dinero ingresado por cada producto (SUBTOTAL ) y mostrar la relación PRODUCTO – SUBTOTAL
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 hernan
Val: 8
Ha aumentado su posición en 4 puestos en Java (en relación al último mes)
Gráfica de Java

vectores paralelos

Publicado por hernan (6 intervenciones) el 13/06/2019 06:57:53
enserio nadie puede hacerlo valla el problema de ser muy difícil
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 Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

vectores paralelos

Publicado por Kabuto (1381 intervenciones) el 13/06/2019 15:45:38
A ver, lo que pasa es que lo interesante sería que pusieras el código que tú llevas hecho, nos digas donde te atascas y te intentamos ayudar a solucionarlo y seguir adelante.
¿Donde tienes dificultades? ¿Al crear una interfaz? ¿Al recoger datos de esa interfaz? ¿Sí los recoges pero luego no sabes como computarlos para hacer el reporte..?

Mira, yo lo he hecho según he entendido el enunciado (que tampoco es muy clarificador), te dejo aquí el cñódigo por si quieres usarlo, mirarlo o lo que sea. Pero lo ideal, repito, sería que se intentara sacar adelante tu própio código.

He creado una interfaz muy básica, es una ventanita pequeña.
Tiene un combobox con 10 Productos, un Textfield no editable donde se muestra el precio del producto seleccionado y otro TextField editable donde el usuario teclea la cantidad que quiere.
Hay dos botones, uno para agregar Producto al listado de ventas y otro para finalizar.
Cuando se pulsa Finalizar, sale una ventana con los datos del reporte que se pide y al cerrarla, todo comienza de nuevo.

Al reporte le he dado algo de color y formato usando código HTML, pero vamos, esto no era necesario y lo he hecho por gusto.

reporte

El código lo he dividido en dos clases.
Una clase se encarga sola y únicamente de crear un JPanel con toda la interfaz.
Contiene los nombres de los Productos y sus precios unitarios.
Al JComboBox le agrega un Listener para que cuando se seleccione un elemento de la lista, cambie el precio que se muestra en el Jtextfield correspondiente.
Tiene varios métodos privados que se encargan de configurar los elementos de la interfaz, que aunque sea sencilla, requiere igualmente algo de código, de ahí que poca gente esté dispuesta a escribirte un programa desde cero (yo es que tengo el dia libre y me aburro, que si no...)
Hay dos métodos públicos para poder ser invocados desde la otra clase, la principal.
Uno de esos métodos retorna la información que está seleccionada en la interfaz, es decir, el nombre del producto, el precio unitario y la cantidad.
El otro método, simplemente resetea la interfaz a su estado original,

Estos métodos serán los que se invoquen cuando se pulse el botón Agregar y necesitemos obtener los datos de la interfaz.

Fíjate que los botones, están declarados como public y no como private, tal y como ocurre con el resto de componentes.
Esto es para poder tener acceso a ellos desde la otra clase y poder añadirles desde ahí el ActionListener que definirá sus acciones a realizar.
¿POr qué el ActionListener lo escribo en la otra clase y no en esta?
Porque la otra clase es la que tiene los Vectores, y necesito que el ActionListener tenga visible esos Vectores, por eso dichos ActionListener los escribiré en la otra clase pero serán añadidos a los botones de esta clase, por eso los dejo como public.
Esta es una de las distintas formas de establecer comunicación entre dos clases, no es ni la mejor ni la peor... lo hago así porque es rápido y perfectamente funcional para este ejercicio.

Aquí te pongo la clase GUI que crea la interfaz.
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
public class GUI extends JPanel{
 
	private JComboBox<String> jc_productos;
	private JTextField jt_precios;
	private JTextField jt_cantidad;
	public JButton bt_agregar;
	public JButton bt_finalizar;
 
	private String[] productos;
	private int[] precios;
 
	public GUI() {
		inicializarComponentes();
		setLayout(new BorderLayout());
		add(new PanelNorte(), BorderLayout.NORTH);
		add(new PanelCentro(), BorderLayout.CENTER);
		add(new PanelSur(), BorderLayout.SOUTH);
	}
 
	public String[] getDatosSeleccionados() {
		//Hay tres datos a devolver: Producto, Precio Unitario y Cantidad

		String[] datos = new String[3];
		datos[0] = (String) jc_productos.getSelectedItem();
		datos[1] = jt_precios.getText();
		datos[2] = jt_cantidad.getText();
		return datos;
	}
 
	public void resetGUI() {
		jc_productos.setSelectedIndex(0);
		jt_precios.setText(Integer.toString(precios[0]));
		jt_cantidad.setText("1");
	}
 
	private void inicializarComponentes() {
		iniciaArraysProductos();
		iniciaComboBox();
		iniciaTextFields();
		iniciaBotones();
	}
 
	private void iniciaArraysProductos() {
		//Prefijamos 10 productos con 10 precios

		productos = new String[] {"Libreta A4 cuadricula", "Libreta A4 con lineas", "Pack 5 boligrafos azules",
				"Pack 5 boligrafos colores", "Pegamento en barra 200g", "Pegamento de contacto", "36 Lápices colores HB",
				"24 Rotuladores Punta Fina", "5 Marcadores Tonos Pastel", "10 Marcadores Tonos Pastel"};
		precios = new int[] {4, 3, 2, 3, 4, 5, 8, 7, 6, 10};
	}
 
	private void iniciaComboBox() {
		jc_productos = new JComboBox<String>();
		for (int i = 0; i < 10; i++)
			jc_productos.addItem(productos[i]);
		jc_productos.addActionListener(new AccionCombo());
	}
 
	private void iniciaTextFields() {
		jt_precios = new JTextField(2);
		jt_precios.setHorizontalAlignment(JTextField.CENTER);
		jt_precios.setText(Integer.toString(precios[0]));
		jt_precios.setEditable(false); //Los precios no son editables por el usuario

		jt_cantidad = new JTextField(2);
		jt_cantidad.setHorizontalAlignment(JTextField.CENTER);
		jt_cantidad.setText("1");
	}
 
	private void iniciaBotones() {
		bt_agregar = new JButton("Agregar");
		bt_finalizar = new JButton("Finalizar");
	}
 
	class PanelNorte extends JPanel {
		public PanelNorte() {
			add(new JLabel("Escoja Producto y Cantidad que desea comprar."));
		}
	}
 
	class PanelCentro extends JPanel {
		public PanelCentro() {
			JPanel pn_producto = new JPanel();
			pn_producto.add(new JLabel("Producto: "));
			pn_producto.add(jc_productos);
			JPanel pn_precio = new JPanel();
			pn_precio.add(new JLabel("Precio Unitario: "));
			pn_precio.add(jt_precios);
			JPanel pn_cantidad = new JPanel();
			pn_cantidad.add(new JLabel("Cantidad a comprar: "));
			pn_cantidad.add(jt_cantidad);
 
			setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
			add(pn_producto);
			add(pn_precio);
			add(pn_cantidad);
		}
	}
 
	class PanelSur extends JPanel {
		public PanelSur() {
			add(bt_agregar);
			add(bt_finalizar);
		}
	}
 
	/*

	 * Listener para cambiar el precio mostrado en la interfaz segun

	 * el producto seleccionado en el ComboBox

	 */
	class AccionCombo implements ActionListener {
		@Override
		public void actionPerformed(ActionEvent e) {
			int indice = jc_productos.getSelectedIndex();
			jt_precios.setText(Integer.toString(precios[indice]));
		}
	}
 
}

La otra clase, llamada VentaProductos, es la que crea el JFrame principal pero usando el JPanel que nos configura la clase anterior.
Te la comento en el siguiente mensaje
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 Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

vectores paralelos

Publicado por Kabuto (1381 intervenciones) el 13/06/2019 15:45:57
Vamos a ver esta clase con un poco más de detenimiento.
Sus atributos son 4: un objeto de la clase GUI, que es la clase anterior que nos da la interfaz con la que trabajar y los Vector paralelos donde guardaremos producto vendido, cantidades y subtotal de ventas de cada producto.

1
2
3
4
5
6
public class VentaProductos extends JFrame{
 
	private GUI interfaz;
	private Vector<String> productos;
	private Vector<Integer> cantidades;
	private Vector<Integer> subtotales;

Su constructor es muy simple, como la clase GUI ya le proporciona la interfaz que necesita, tan solo inicializa atributos, coloca la interfaz en el JFrame, lo configura y lo hace visible.
Fíjate que es aquí donde accedemos a los botones que antes hemos dejado como public para añadirles a cada uno su ActionListener, que luego veremos su código

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public VentaProductos() {
    super("Venta Productos");
    interfaz = new GUI();
    interfaz.bt_agregar.addActionListener(new AccionAgregar());
    interfaz.bt_finalizar.addActionListener(new AccionFinalizar());
    interfaz.bt_finalizar.setEnabled(false);
    productos = new Vector<String>();
    cantidades = new Vector<Integer>();
    subtotales = new Vector<Integer>();
 
    getContentPane().add(interfaz);
 
    pack();
    setLocationRelativeTo(null);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setVisible(true);
}

El metodo main() no hace nada. Tan solo instancia a esta misma clase para poner en marcha el JFrame.

1
2
3
public static void main(String[] args) {
    new VentaProductos();
}

Ahora viene lo interesante.
El siguiente código es una subclase que implemente la interfaz ActionListener y es la que le proporcionaremos al boton Agregar para decirle que tiene que hacer cuando el usuario clicke en él.

Básicamente lo que hace es:
- Le pide a la interfaz los datos que ha elegido el usuario. EStos datos llegan en un array con 3 Strings: Nombre, producto, precio y cantidad
- Calcula el importe de esta venta segun el precio y la cantidad.
- Comprueba si el Producto elegido ya existe en el Vector de productos. Para ello le pide al Vector que le devuelva un indice que coincida con el Producto actual.
Si no hay ninguno, el Vector devuelve como indice el valor -1. Esto significa que no existe este Producto en el Vector, es la primera compra que se hace, y por lo tanto tan solo tenemos que añadir los valores a los Vectores correspondientes.
En cambio, si ya hay un Producto con el mismo nombre en el Vector, este nos devuelve el indice donde podemos encontrarlo. En este caso, tenemos que actualizar los datos sumando la cantidad actual a la cantidad ya guarda en el Vector de cantidades, y lo mismo para el subtotal de ventas.

Y luego reinicia la interfaz para que el usuario pueda hacer una nueva compra o poner fin.

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
class AccionAgregar implements ActionListener {
    @Override
    public void actionPerformed(ActionEvent e) {
        try {
            String[] datosInterfaz = interfaz.getDatosSeleccionados();
            Integer importeVenta = Integer.parseInt(datosInterfaz[1]) *
                    Integer.parseInt(datosInterfaz[2]);
            /*

             * Comprobamos si el Producto seleccionado ya está en los Vectores.

             * Si no está, se agregan los datos sin más.

             * Si ya existe, se actualizan los datos de los vectores

             */
            int indice = productos.indexOf(datosInterfaz[0]);
            if (indice == -1) { //No existe este Producto en los vectores

                productos.add(datosInterfaz[0]);
                cantidades.add(Integer.parseInt(datosInterfaz[2]));
                subtotales.add(importeVenta);
            }
            else { //Si existe, actualizamos datos

                Integer cantidad = cantidades.get(indice);
                cantidad += Integer.parseInt(datosInterfaz[2]);
                cantidades.set(indice, cantidad);
                Integer subtotal = subtotales.get(indice);
                subtotal += importeVenta;
                subtotales.set(indice, subtotal);
            }
            //Venta registrada.

            interfaz.resetGUI();
            interfaz.bt_finalizar.setEnabled(true); //Ahora si se puede finalizar y reportar

        }
        catch(NumberFormatException ex) {
            JOptionPane.showMessageDialog(null, "El campo Cantidad no contiene un valor numérico válido.",
                    "Error Agregando Producto", JOptionPane.ERROR_MESSAGE);
        }
 
    }
}


Lo siguiente, y ya último, el el ActionListener para generar el Reporte.
Para el reporte se piden varios datos, entonces lo que he hecho es que esta clase incorpore variso submetodos, cada uno se encarga de calcular una de las cosas que piden.
Cuando consiguen dichos cálculos, los devuelven en un String.
Con cada uno de estos String, construyo un único String, el cuál como dije antes, incorpora código HTML para presentar los datos con algo de color y formato.
Dicho reporte lo muestro en una ventana tipo JOptionPane. Hay otros componentes Swing más adecuados para esto, pero para ir rápidos ya nos va bien hacerlo así.

Cuando el usuario cierra el JOptionPane, todos los vectores se reinician para que comience un nuevo proceso de compras.

Este es el ActionListener. Como digo tiene varios métodos internos, es para que cada uno se dedique a una tarea concreta.

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
class AccionFinalizar implements ActionListener {
    @Override
    public void actionPerformed(ActionEvent e) {
        //Construiremos un reporte con codigo HTML para una mejor presentacion

        StringBuilder reporte = new StringBuilder();
        reporte.append("<html><body>");
        reporte.append("<h1 align=\"center\"><u>REPORTE VENTAS</u></h1>");
        reporte.append("<h2>Productos más y menos vendido</h2>");
        reporte.append(productoMasMenosVendido());
        reporte.append("<hr><h2>Importe total de ventas</h2>");
        reporte.append(ventaTotal());
        reporte.append("<hr><h2>Porcentajes de venta por Producto</h2>");
        reporte.append(porcentajesPorProducto());
        reporte.append("<hr><h2>Subtotales de venta por Producto</h2>");
        reporte.append(subTotales());
        reporte.append("<h1 align=\"center\"><u>FIN DEL REPORTE</u></h1>");
        reporte.append("</body></html>");
 
        JOptionPane.showMessageDialog(null, reporte.toString(),
                "Reporte Final", JOptionPane.PLAIN_MESSAGE);
        //Tras el Reporte, se reinician todos los datos

        interfaz.resetGUI();
        productos.removeAllElements();
        cantidades.removeAllElements();
        subtotales.removeAllElements();
        interfaz.bt_finalizar.setEnabled(false);
    }
 
    private String productoMasMenosVendido() {
        int mayorCantidad = cantidades.get(0);
        int menorCantidad = cantidades.get(0);
        String mayorProducto = productos.get(0);
        String menorProducto = productos.get(0);
 
        for (int i = 0; i < productos.size(); i++) {
            if (cantidades.get(i) > mayorCantidad) {
                mayorCantidad = cantidades.get(i);
                mayorProducto = productos.get(i);
            }
            if (cantidades.get(i) < menorCantidad) {
                menorCantidad = cantidades.get(i);
                menorProducto = productos.get(i);
            }
        }
 
        return "<p style=\"color:blue;\">Producto más vendido: <i style=\"color:red;\">" + mayorProducto + "</i>"
                + "<br>Cantidad: <i style=\"color:red;\">" + mayorCantidad + "</i></p>"
                + "<p style=\"color:blue;\">Producto menos vendido: <i style=\"color:red;\">" + menorProducto + "</i>"
                + "<br>Cantidad: <i style=\"color:red;\">" + menorCantidad + "</i></p>";
    }
 
    private String ventaTotal() {
        int totalVentas = 0;
        for (Integer subtotal: subtotales)
            totalVentas += subtotal;
 
        return "<p style=\"color:blue;\">Importe: <i style=\"color:red;\">" + totalVentas + " €</i></p>";
    }
 
    private String porcentajesPorProducto() {
        int totalVentas = 0;
        for (Integer subtotal: subtotales)
            totalVentas += subtotal;
 
        //Por cada Producto vendido, construiremos un String con los datos a reportar

        StringBuilder porcentajes = new StringBuilder();
        porcentajes.append("<ul style=\"color:blue;\">");
        for (int i = 0; i < productos.size(); i++) {
            double porcentaje = subtotales.get(i) * 100 / totalVentas;
            porcentajes.append(String.format("<li>Producto: <i style=\"color:red;\">%s</i>"
                    + " Porcentaje: <i style=\"color:red;\">%.2f &#37;</i></li>",
                    productos.get(i), porcentaje));
        }
        porcentajes.append("</ul>");
 
        return porcentajes.toString();
    }
 
    private String subTotales() {
        StringBuilder subTotales = new StringBuilder();
        subTotales.append("<ul style=\"color:blue;\">");
        for (int i = 0; i < productos.size(); i++) {
            subTotales.append(String.format("<li>Producto: <i style=\"color:red;\">%s</i>"
                    + " SubTotal: <i style=\"color:red;\">%d €</i></li>",
                    productos.get(i), subtotales.get(i)));
        }
        subTotales.append("</ul>");
 
        return subTotales.toString();
    }
}

Y ahora te pongo el código completo, por si quieres copiarlo todo de una sola vez.
Pruébalo, revísalo, pregunta cualquier cosa que no entiendas y a ser posible, úsalo para comprender mejor como solucionar tu própio código.
Un saludo.

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
public class VentaProductos extends JFrame{
 
	private GUI interfaz;
	private Vector<String> productos;
	private Vector<Integer> cantidades;
	private Vector<Integer> subtotales;
 
	public VentaProductos() {
		super("Venta Productos");
		interfaz = new GUI();
		interfaz.bt_agregar.addActionListener(new AccionAgregar());
		interfaz.bt_finalizar.addActionListener(new AccionFinalizar());
		interfaz.bt_finalizar.setEnabled(false);
		productos = new Vector<String>();
		cantidades = new Vector<Integer>();
		subtotales = new Vector<Integer>();
 
		getContentPane().add(interfaz);
 
		pack();
		setLocationRelativeTo(null);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setVisible(true);
	}
 
	public static void main(String[] args) {
		new VentaProductos();
	}
 
	class AccionAgregar implements ActionListener {
		@Override
		public void actionPerformed(ActionEvent e) {
			try {
				String[] datosInterfaz = interfaz.getDatosSeleccionados();
				Integer importeVenta = Integer.parseInt(datosInterfaz[1]) *
						Integer.parseInt(datosInterfaz[2]);
				/*

				 * Comprobamos si el Producto seleccionado ya está en los Vectores.

				 * Si no está, se agregan los datos sin más.

				 * Si ya existe, se actualizan los datos de los vectores

				 */
				int indice = productos.indexOf(datosInterfaz[0]);
				if (indice == -1) { //No existe este Producto en los vectores

					productos.add(datosInterfaz[0]);
					cantidades.add(Integer.parseInt(datosInterfaz[2]));
					subtotales.add(importeVenta);
				}
				else { //Si existe, actualizamos datos

					Integer cantidad = cantidades.get(indice);
					cantidad += Integer.parseInt(datosInterfaz[2]);
					cantidades.set(indice, cantidad);
					Integer subtotal = subtotales.get(indice);
					subtotal += importeVenta;
					subtotales.set(indice, subtotal);
				}
				//Venta registrada.

				interfaz.resetGUI();
				interfaz.bt_finalizar.setEnabled(true); //Ahora si se puede finalizar y reportar

			}
			catch(NumberFormatException ex) {
				JOptionPane.showMessageDialog(null, "El campo Cantidad no contiene un valor numérico válido.",
						"Error Agregando Producto", JOptionPane.ERROR_MESSAGE);
			}
 
		}
	}
 
	class AccionFinalizar implements ActionListener {
		@Override
		public void actionPerformed(ActionEvent e) {
			//Construiremos un reporte con codigo HTML para una mejor presentacion

			StringBuilder reporte = new StringBuilder();
			reporte.append("<html><body>");
			reporte.append("<h1 align=\"center\"><u>REPORTE VENTAS</u></h1>");
			reporte.append("<h2>Productos más y menos vendido</h2>");
			reporte.append(productoMasMenosVendido());
			reporte.append("<hr><h2>Importe total de ventas</h2>");
			reporte.append(ventaTotal());
			reporte.append("<hr><h2>Porcentajes de venta por Producto</h2>");
			reporte.append(porcentajesPorProducto());
			reporte.append("<hr><h2>Subtotales de venta por Producto</h2>");
			reporte.append(subTotales());
			reporte.append("<h1 align=\"center\"><u>FIN DEL REPORTE</u></h1>");
			reporte.append("</body></html>");
 
			JOptionPane.showMessageDialog(null, reporte.toString(),
					"Reporte Final", JOptionPane.PLAIN_MESSAGE);
			//Tras el Reporte, se reinician todos los datos

			interfaz.resetGUI();
			productos.removeAllElements();
			cantidades.removeAllElements();
			subtotales.removeAllElements();
			interfaz.bt_finalizar.setEnabled(false);
		}
 
		private String productoMasMenosVendido() {
			int mayorCantidad = cantidades.get(0);
			int menorCantidad = cantidades.get(0);
			String mayorProducto = productos.get(0);
			String menorProducto = productos.get(0);
 
			for (int i = 0; i < productos.size(); i++) {
				if (cantidades.get(i) > mayorCantidad) {
					mayorCantidad = cantidades.get(i);
					mayorProducto = productos.get(i);
				}
				if (cantidades.get(i) < menorCantidad) {
					menorCantidad = cantidades.get(i);
					menorProducto = productos.get(i);
				}
			}
 
			return "<p style=\"color:blue;\">Producto más vendido: <i style=\"color:red;\">" + mayorProducto + "</i>"
					+ "<br>Cantidad: <i style=\"color:red;\">" + mayorCantidad + "</i></p>"
					+ "<p style=\"color:blue;\">Producto menos vendido: <i style=\"color:red;\">" + menorProducto + "</i>"
					+ "<br>Cantidad: <i style=\"color:red;\">" + menorCantidad + "</i></p>";
		}
 
		private String ventaTotal() {
			int totalVentas = 0;
			for (Integer subtotal: subtotales)
				totalVentas += subtotal;
 
			return "<p style=\"color:blue;\">Importe: <i style=\"color:red;\">" + totalVentas + " €</i></p>";
		}
 
		private String porcentajesPorProducto() {
			int totalVentas = 0;
			for (Integer subtotal: subtotales)
				totalVentas += subtotal;
 
			//Por cada Producto vendido, construiremos un String con los datos a reportar

			StringBuilder porcentajes = new StringBuilder();
			porcentajes.append("<ul style=\"color:blue;\">");
			for (int i = 0; i < productos.size(); i++) {
				double porcentaje = subtotales.get(i) * 100 / totalVentas;
				porcentajes.append(String.format("<li>Producto: <i style=\"color:red;\">%s</i>"
						+ " Porcentaje: <i style=\"color:red;\">%.2f &#37;</i></li>",
						productos.get(i), porcentaje));
			}
			porcentajes.append("</ul>");
 
			return porcentajes.toString();
		}
 
		private String subTotales() {
			StringBuilder subTotales = new StringBuilder();
			subTotales.append("<ul style=\"color:blue;\">");
			for (int i = 0; i < productos.size(); i++) {
				subTotales.append(String.format("<li>Producto: <i style=\"color:red;\">%s</i>"
						+ " SubTotal: <i style=\"color:red;\">%d €</i></li>",
						productos.get(i), subtotales.get(i)));
			}
			subTotales.append("</ul>");
 
			return subTotales.toString();
		}
	}
 
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar