Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Java » resolución de un ejercicio compareTo(Ayuda)

Java - resolución de un ejercicio compareTo(Ayuda)

Volver
Nuevo Tema
<<>>
 
Vista:
sin imagen de perfil
Val: 7
Ha aumentado su posición en 5 puestos en Java (en relación al último mes)
Gráfica de Java

resolución de un ejercicio compareTo(Ayuda)

Publicado por david (4 intervenciones) el 14/05/2020 17:42:52
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
public class test {
 
	public static void main (String[] args) {
 
		manzana[] manzanas = new manzana[10];
		manzanas[0] = new manzana("verde","smith",4);
		manzanas[1] = new manzana("amarilla","smith",9);
		manzanas[2] = new manzana("amarilla","smith",8);
		manzanas[3] = new manzana("verde","smith",6);
		manzanas[4] = new manzana("verde","smith",5);
		manzanas[5] = new manzana("roja","smith",4);
		manzanas[6] = new manzana("amarilla","smith",12);
		manzanas[7] = new manzana("roja","smith",10);
		manzanas[8] = new manzana("roja","smith",13);
		manzanas[9] = new manzana("verde","smith",7);
 
		manzana temp;
 
		for(int i=0;i<10;i++){
		   for(int j=i+1;j<10;j++){
			 if(manzanas[i].compareTo(manzanas[j])>0){
				temp= manzanas[j];
				manzanas[j] = manzanas[j-1];
				manzanas[j-1] = temp;
			   }
			   }
			 }
 
		 System.out.println("_____________________");
		for(int i=0;i<10;i++){
			System.out.println(manzanas[i].toString());
		}
		}
}
 
public class manzana implements Comparable <manzana> {
 
	 private String color;
	 private String variedad;
	 private int peso;
 
	 manzana(String color,String variedad,int peso){
		 this.color = color;
		 this.variedad = variedad;
		 this.peso = peso;
	 }
	public int getPeso(){
		return peso;
	}
	public void setPeso(int peso){
		this.peso = peso;
	}
	public String getColor(){
		return color;
	}
	public void setColor(String color){
		this.color = color;
	}
 
	 public String toString(){
		 return "Color: "+color+" Variedad: "+variedad+" Peso: "+peso;
	 }
 
	public int compareTo(manzana o){
		int resultado = 0;
	    if(this.color.equals(o.color)){
			if(this.peso<o.peso){
				resultado = 1;
			}else if(this.peso>o.peso){
				resultado = -1;
			}
 
		}else{
			if(this.color.compareTo(o.color) == 0){
				resultado = 1;
			}else if(this.color.compareTo(o.color)>1){
				resultado = -1;
			}else{
				resultado = 0;
			}
		}
		return resultado;
	 }
 
}

La cuestion es que no se como hacer para que el compareTo ordene primero por colores en orden de verde,rojo,amarillo(En orden de z a a), y depues de ordenarlo por color ordene segun el peso siendo de menor a mayor las manzanas verdes, de menor a mayor las rojas...
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

resolución de un ejercicio compareTo(Ayuda)

Publicado por Kabuto (1385 intervenciones) el 14/05/2020 20:26:57
Hola.
Suena complicado, pero no lo es tanto.

Lo primero que hemos de comparar es el color.
Si es igual, ambas manzanas tienen mismo color, entonces ahora quien decide es el peso y retornaremos el resultado de comparar sus pesos.

Si son de distinto color, entonces ahora no importa el peso, solo importa comparar los colores y retornar el valor de comparar lexicográficamente(menuda palabrita) los String que representan el color.

La clase String ya trae de serie su propio método compareTo(), así que podemos usarlo para comparar los colores y retornar el resultado.
El único problema, es que el compareTo() de String ordena de menor a mayor, es decir:
- la A es menor que la B..
- la B es menor que la C..

Es decir, ordena de la A a la Z

Y nosotros para este ejercicio necesitamos lo opuesto, ordenar de la Z a la A.
Pero solucionarlo es muy fácil. Como sabes, compareTo() devuelve un int que puede ser - 1 si el objeto principal es menor, +1 si es mayor ó valor 0 si son iguales.

Bien, como necesitamos lo opuesto, nos basta con multiplicar el resultado que nos de el compareTo() por -1.
Así invertiremos el signo e invertiremos la comparación para poder ordenar como deseamos.

El método compareTo() para Manzana (las clases comienzan con mayúscula en Java) sería:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Override
public int compareTo(Manzana o){
 
    if (color.equals(o.color)) {//Manzana mismo color, ahora depende del peso
        if (peso == o.peso)
            return 0; //Mismo color, mismo peso.
        else if (peso < o.peso)
            return -1; //Mismo color, esta manzana pesa menos
        else
            return 1; //Mismo color, esta manzana pesa más
    }
    else //Distinto color
        //En este caso, nos sirve la comparacion de Strings, pero invirtiéndola con -1
        return color.compareTo(o.color) * -1;
    }

Vale, tenemos método comparteTo().
¿Cómo asegurarnos de que funciona?
En la clase principal, para asegurarnos de que no nos equivocamos nosotros al usar los bucles de ordenación, podemos pedirle a la clase Arrays que nos ordene nuestro arreglo.
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
public class Test {
 
	public static void main (String[] args) {
 
		Manzana[] manzanas = new Manzana[10];
		manzanas[0] = new Manzana("verde","smith",4);
		manzanas[1] = new Manzana("amarilla","smith",9);
		manzanas[2] = new Manzana("amarilla","smith",8);
		manzanas[3] = new Manzana("verde","smith",6);
		manzanas[4] = new Manzana("verde","smith",5);
		manzanas[5] = new Manzana("roja","smith",4);
		manzanas[6] = new Manzana("amarilla","smith",12);
		manzanas[7] = new Manzana("roja","smith",10);
		manzanas[8] = new Manzana("roja","smith",13);
		manzanas[9] = new Manzana("verde","smith",7);
 
		//Pedimos a la clase Arrays que ordene el array
		Arrays.parallelSort(manzanas);
 
		//Aquí intentaremos ordenar por nuestra cuenta
		//cuando sepamos que funciona el método compareTo()
		/*
		for(int i=0;i<10;i++){
			for(int j=i+1;j<10;j++){
				if(manzanas[i].compareTo(manzanas[j])>0){
					Manzana temp= manzanas[j];
					manzanas[j] = manzanas[j-1];
					manzanas[j-1] = temp;
				}
			}
		}*/
 
		System.out.println("_____________________");
		for(int i=0;i<10;i++){
			System.out.println(manzanas[i].toString());
		}
	}
}

Y si vemos el resultado en pantalla, podemos comprobar que se ha ordenado como deseábamos.
Así que el método compareTo() funciona bien.

1
2
3
4
5
6
7
8
9
10
11
_____________________
Color: verde Variedad: smith Peso: 4
Color: verde Variedad: smith Peso: 5
Color: verde Variedad: smith Peso: 6
Color: verde Variedad: smith Peso: 7
Color: roja Variedad: smith Peso: 4
Color: roja Variedad: smith Peso: 10
Color: roja Variedad: smith Peso: 13
Color: amarilla Variedad: smith Peso: 8
Color: amarilla Variedad: smith Peso: 9
Color: amarilla Variedad: smith Peso: 12


Bien, ahora intentamos ordenar con bucles y no con el comodísimo método de la clase Arrays

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
public class Test {
 
	public static void main (String[] args) {
 
		Manzana[] manzanas = new Manzana[10];
		manzanas[0] = new Manzana("verde","smith",4);
		manzanas[1] = new Manzana("amarilla","smith",9);
		manzanas[2] = new Manzana("amarilla","smith",8);
		manzanas[3] = new Manzana("verde","smith",6);
		manzanas[4] = new Manzana("verde","smith",5);
		manzanas[5] = new Manzana("roja","smith",4);
		manzanas[6] = new Manzana("amarilla","smith",12);
		manzanas[7] = new Manzana("roja","smith",10);
		manzanas[8] = new Manzana("roja","smith",13);
		manzanas[9] = new Manzana("verde","smith",7);
 
		/*
		//Pedimos a la clase Arrays que ordene el array
		Arrays.parallelSort(manzanas);
		*/
 
		//Aquí intentaremos ordenar por nuestra cuenta
		//cuando sepamos que funciona el método compareTo()
 
		for(int i=0;i<10;i++){
			for(int j=i+1;j<10;j++){
				if(manzanas[i].compareTo(manzanas[j])>0){
					Manzana temp= manzanas[j];
					manzanas[j] = manzanas[j-1];
					manzanas[j-1] = temp;
				}
			}
		}
 
		System.out.println("_____________________");
		for(int i=0;i<10;i++){
			System.out.println(manzanas[i].toString());
		}
	}
}

Pero el ordenamiento no ha salido como esperábamos.


Aunque ha fallado por muy poco. Son un par de elementos los que se han quedado donde no deberían.
Revisa los bucles que usas para ordenar. A ver si lo consigues solucionar. Si no, dilo por aquí y te ayudamos.
Un saludo.

1
2
3
4
5
6
7
8
9
10
11
_____________________
Color: verde Variedad: smith Peso: 4
Color: amarilla Variedad: smith Peso: 8
Color: verde Variedad: smith Peso: 5
Color: verde Variedad: smith Peso: 6
Color: roja Variedad: smith Peso: 4
Color: roja Variedad: smith Peso: 10
Color: verde Variedad: smith Peso: 7
Color: roja Variedad: smith Peso: 13
Color: amarilla Variedad: smith Peso: 9
Color: amarilla Variedad: smith Peso: 12
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