Java - Problemas con un ArrayList

 
Vista:
sin imagen de perfil
Val: 9
Ha aumentado su posición en 4 puestos en Java (en relación al último mes)
Gráfica de Java

Problemas con un ArrayList

Publicado por Abel (6 intervenciones) el 12/03/2019 12:01:16
Tengo el siguiente proyecto, lo que quiero es evitar que el usuario introduzca precios diferentes para el mismo producto. Una vez ha "comprado" un producto, si quiere volver a comprarlo deberá ser al precio que decidió antes. Así que solo incrementaré la cantidad del producto sin modificar el precio.
todo lo tengo dentro de un switch, y al ejecutarse el metodo comprobarProducto, al introducir otra vez los productos, sin pedirme el precio, me da error.
Este método esta en el main:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
private static void comprobarProducto(List <Producto> listper, String producto){
    Producto pextra=new Producto ();
    Scanner sc=new Scanner (System.in);
    boolean repetido=false;
    listper.contains(producto); //esto no me funciona para comprobar si tiene el producto, siempre me da false
    for(Producto c:listper){
        if(c.getDescripcion()==producto){ //si el producto de la lista es el mismo que el del metodo se pide solo la cantidad
            repetido=true;
        }
    }
    if(repetido){
        int posicion=listper.indexOf(producto);
        System.out.println("¿Cuántos "+producto+" quieres de nuevo?");
        int cantidad=(listper.get(posicion).getCantidad())+sc.nextInt();
        pextra.setCantidad(cantidad);
        pextra.setDescripcion(producto);
        pextra.setPrecio(listper.get(posicion).getPrecio());
        listper.add(posicion,pextra);
    }else{
        pextra.rellenarLista(producto);
        listper.add(pextra);
    }
}
Y este es el de Producto, que es el que invoco en el método estático.
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
package compraventalinked;
 
import java.util.List;
import java.util.Scanner;
 
public class Producto {
    private int cantidad;
    private String descripcion;
    private float precio;
 
    public Producto() {
 
    }
 
    public Producto( int cantidad, String descripcion, float precio) {
 
        this.cantidad = cantidad;
        this.descripcion = descripcion;
        this.precio = precio;
    }
 
    public int getCantidad() {
        return cantidad;
    }
 
    public void setCantidad(int cantidad) {
        this.cantidad = cantidad;
    }
 
    public String getDescripcion() {
        return descripcion;
    }
 
    public void setDescripcion(String descripcion) {
        this.descripcion = descripcion;
    }
 
    public float getPrecio() {
        return precio;
    }
 
    public void setPrecio(float precio) {
        this.precio = precio;
    }
 
    public void venderInformacion(){
 
    }
    public void venderProducto(){
        Scanner sc=new Scanner (System.in);
        System.out.println("¿Cuantos "+descripcion+" quiere?");
        int vendido=sc.nextInt();
 
        while(cantidad<vendido){
            System.out.println("No tenemos esa cantidad de productos. Actualmente tenemos "+cantidad+" "+descripcion);
            System.out.println("Cuantos productos te quieres llevar ahora: ");
            vendido=sc.nextInt();
        }
        cantidad=cantidad - vendido;
        System.out.println("Deberá pagar: "+precio*vendido+"€");
    }
    public void devolverProducto(){
        cantidad++;
        System.out.println("El dinero a devolver es de: "+precio+"€");
    }
 
    public void rellenarLista(String producto){
        Scanner sc=new Scanner (System.in);
        descripcion=producto;
        System.out.println("¿Cuantos "+descripcion+" quiere?");
        cantidad=sc.nextInt();
        System.out.println("Cuál es el precio por cada producto");
        precio=sc.nextFloat();
    }
 
    public float precioFinal(){
        float preciofinal=precio*cantidad;
        return preciofinal;
    }
}


Muchas gracias
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 Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Problemas con un ArrayList

Publicado por Kabuto (1381 intervenciones) el 12/03/2019 12:33:30
El problema es que el List contiene objetos de la clase Producto, pero tú estás intentado hacer comparaciones y búsquedas pasándole un objeto de la clase String.

1
listper.contains(producto);

Esto siempre te da false porque "producto" es un String y listper "no contiene" ningún String, contiene Productos

Por esa misma causa, esto tampoco te va a dar resultado:
1
int posicion=listper.indexOf(producto);

Para que esto te funcionase bien, el objeto "producto" no puede ser un String, ha de ser clase Producto. Y además a la clase Producto tendrías que sobreescribir el método equals() (que TODAS las clases heredan de la superclase Object, aunque no lo veamos) para "enseñarle" al compilador cómo saber si dos objetos Producto son "equivalentes".

El método .contains() de ArrayList te habrá funcionado bien en otras ocasiones trabajando con Strings, porque el compilador ya sabe cuando un String es equivalente (equals() ) a otro String. Esto ya lo trae de serie.

Pero de serie no sabe cuando un Producto equivale a otro Producto, esto tienes que enseñarselo tú sobreescribiendo el método equals() a tu clase Producto.
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

Problemas con un ArrayList

Publicado por Kabuto (1381 intervenciones) el 12/03/2019 13:16:26
Extiendo mi respuesta.

Para "enseñarle" al compilador como saber comparar objetos Producto, has de añadir esto al código de tu clase.
Pongo comentarios explicativos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@Override
	public boolean equals(Object objeto) {
 
		if (objeto instanceof Producto) {//El objeto que vamos a comparar, es una instancia de clase Producto
			/*
			 * Tenemos un objeto de la clase Producto,
			 * pero nos ha llegado intanciado como Object (polimorfismo).
			 * Lo reinstanciamos a la clase Producto para poder trabajar con el.
			 */
			Producto otroProducto = (Producto)objeto;
			/*
			 * Ya lo hemos reinstanciado como Producto.
			 * Ahora vamos a indicar como decidimos si dos Productos son equivalentes.
			 * Vamos a considerar que dos Productos son equivalentes, si tienen exactamente
			 * la misma descripción. 
			 */
			if (this.descripcion.equals(otroProducto.getDescripcion()))
				return true; //Descripciones coinciden, SON PRODUCTOS EQUIVALENTES
			else
				return false; //Descripciones no coinciden, SON PRODUCTOS DISTINTOS
		}
		else //El objeto no es de clase Producto, devolvemos false
			return false;
	}

Con esto, el compilador ya sabe como usar correctamente el método equals() para comparar objetos Producto.

Así mismo, el ArrayList nos dará resultados más correctos cuando usemos sus métodos contains() e indexOf(), ya que internamente, se vale del método equals() cuando llamamos a dichos métodos.

Dejo un programita de pruebas sencillo.
En él creo tres productos: pr1, p2 y pr3.
pr1 y pr3 tienen la misma descripción, esto no es un error, lo hago intencionadamente para que se vea que aunque son dos objetos distintos, cada uno con su propio puntero y referencia interna, al tener la misma descripcion se consideran equivalentes, ya que así lo hemos establecido en el método equals().

Atención a los comentarios, sobre todo al último donde menciono un detalle importante.

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
import java.util.ArrayList;
 
public class Prueba {
 
	static ArrayList<Producto> productos = new ArrayList<>();
 
	public static void main(String[] args) {
 
 
		Producto pr1 = new Producto(1, "Producto1", 0f);
		Producto pr2 = new Producto(1, "Producto2", 0f);
		Producto pr3 = new Producto(1, "Producto1", 0f);
 
		System.out.println("Probando metodo equals()....\n");
 
		System.out.println("¿pr1 es equivalente a pr1?: " + pr1.equals(pr1));
		System.out.println("¿pr1 es equivalente a pr2?: " + pr1.equals(pr2));
		System.out.println("¿pr1 es equivalente a pr3?: " + pr1.equals(pr3));
 
		System.out.println("\nProbando metodos contains() e indexOf()...");
		System.out.println("(Ambos se sirven del método equals())\n");
 
		productos.add(pr1);
		productos.add(pr2);
		productos.add(pr3);
 
		//Pasamos un producto de los que ya hemos creado
		if (productos.contains(pr1))
			System.out.println("Sí está contenido pr1");
 
		//Pasamos un nuevo Producto, pero que es equivalente a pr2
		if (productos.contains(new Producto(3, "Producto2", 45f)))
			System.out.println("Sí está contenido pr2");
 
		//Preguntamos por indice de pr2
		System.out.println("\nIndice de pr2: " + productos.indexOf(pr2));
 
		//Preguntamos por indice de pr1
		System.out.println("Indice de pr1: " + productos.indexOf(pr1));
 
		/*
		 * Preguntamos por indice de pr3.
		 * ATENCION, veremos que nos da el mismo índice que
		 * tiene pr1, no nos da el de pr3.
		 * Esto es porque pr3 es equivalente a pr1, ya que tienen
		 * la misma descripcion.
		 * ArrayList permite añadir objetos "equivalentes" y puede
		 * ocasionar estos problemas. Deberemos controlar nosotros
		 * el evitar añadir objetos equivalentes.
		 * 
		 * De lo contrario, los métodos indexOf() y contains()
		 * pueden darnos resultados confusos.
		 */
		System.out.println("Indice de pr3: " + productos.indexOf(pr3));
 
	}
 
}

Este es el resultado que da en pantalla:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Probando metodo equals()....
 
¿pr1 es equivalente a pr1?: true
¿pr1 es equivalente a pr2?: false
¿pr1 es equivalente a pr3?: true
 
Probando metodos contains() e indexOf()...
(Ambos se sirven del método equals())
 
Sí está contenido pr1
Sí está contenido pr2
 
Indice de pr2: 1
Indice de pr1: 0
Indice de pr3: 0
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: 9
Ha aumentado su posición en 4 puestos en Java (en relación al último mes)
Gráfica de Java

Problemas con un ArrayList

Publicado por Abel (6 intervenciones) el 14/03/2019 18:39:43
Muchas gracias por tu rapida respuesta. Por desgracia no lo he podido hacer asi y he tenido que buscar otro metodo. Pero aún, muchas gracias. Aprendo mucho en este foro con vuestra ayuda. Para la próxima vez ya sabre cual es el error y no me volveré loco. Muchas gracias de nuevo,

Un saludo,
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