Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Java » AYUDAA no entiendo como manejar el arraylist dentro de una clase

Java - AYUDAA no entiendo como manejar el arraylist dentro de una clase

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

AYUDAA no entiendo como manejar el arraylist dentro de una clase

Publicado por java (1 intervención) el 12/05/2020 00:48:35
este es el ejercicio q encontre por internet, esta interesante pero me hizo un dolor de cabeza jajaja

1. Defina la clase EquipoDeBasquet la cual permite registrar los jugadores titulares de un equipo de básquet (recuerde que la cantidad de jugadores es cinco). La clase además de los métodos necesarios para su correcta definición implementa los siguientes métodos:

a. incorporarJugadorTitular(j) este método recibe como parámetro un jugador de básquet y lo incorpora al equipo. El método no retorna un resultado.
b. eliminarJugadorTitular(j) este método recibe como parámetro un jugador de básquet y lo elimina del equipo. El método retrona verdadero si se pudo eliminar el jugador y falso en otro caso.
c. masTriples() dicho método imprime por pantalla el nombre del jugador de básquet que ha convertido más tripes. Si hay varios jugadores con la misma cantidad de triples se retorna el primero.

2. Desarrolle un programa que:

a. Defina dos equipos de basquet
b. Incorpore los jugadores correspondientes a cada uno de ellos
c. Imprima por pantalla los jugadores de cada equipo que más triples hicieron.
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

AYUDAA no entiendo como manejar el arraylist dentro de una clase

Publicado por Kabuto (1381 intervenciones) el 12/05/2020 21:09:32
Vamos por partes.

Tu clase JugadorDeBasquet, en principio, es correcta.
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
public class JugadorDeBasquet {
 
    private String nombre;
    private int cantidadTriples;
 
    public String getNombre() {
        return nombre;
    }
 
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
 
    public int getCantidadTriples() {
        return cantidadTriples;
    }
 
    public void setCantidadTriples(int cantidadTriples) {
        this.cantidadTriples = cantidadTriples;
    }
 
    public void imprimir(){
        System.out.println("");
        System.out.println("    Nombre: " + this.getNombre());
        System.out.println("    Cantidad de Triples: " + this.getCantidadTriples());
    }
 
}

La siguiente clase EquipoDeBasquet, hay cosas que corregir.

Esta clase, no tiene que heredar de JugadorDeBasquet.
Si hacemos eso, estamos diciendo que un equipo, es además, un jugador... y eso no tiene sentido.
Entre estas dos clases, hay una relación, pero no es una relación de herencia.
Es una relación de agregación.

Un equipo se compone de jugadores, pero un equipo no es un jugador.
Para este tipo de relación no se necesita ninguna instrucción ni palabra clave.
Simplemente basta con el atributo ArrayList de objetos JugadorDeBasquet. Con esto ya estamos diciendo que un Equipo se compone de Jugadores.

El atributo ArrayList, mejor si lo ponemos como private. Y también mejor si no tiene getter ni setter.
Los getter y setter no son obligatorios para cada atributo de la clase. Especialmente los que son colecciones de datos como ArrayList, HashMap, Vector, etc..., excepto en casos concretos, no vamos a necesitar ni desear devolver la colección completa con un get, ni tampoco dar opción de sustituirla por completo mediante un set.
Si no hay algún motivo de peso, es mejor que no tengan ni get ni set.

El método para agregarJugador es correcto.

Pero el de eliminar jugador requiere alguna corrección.
Fíjate que el enunciado dice que ha de devolver verdadero o falso, así que ha de ser de tipo boolean.
Y dice que ha de recibir un JugadorDeBasquet, no un int a modo de indice.
Así que el método correcto sería este:
1
2
3
public boolean eliminarJugadorTitular(JugadorDeBasquet unBasquebolista){
        return jdrB.remove(unBasquebolista);
    }

Escrito así, el ArrayList busca en su interior si tiene un JugadorDeBasquet equivalente al recibido por parámetro e intenta eliminarlo.
Su propio método remove() ya es boolean, así que retornamos el resultado de intentar borrar el jugador.
Pero aquí se nos presenta un problema importante.
¿Cómo sabe el ArrayList cuándo un JugadorDeBasquet es equivalente a otro?
Pues la verdad es que no lo sabe, así que probablemente no funcione bien esto.

Tenemos que decidir nosotros cuándo dos JugadorDeBasquet son equivalentes, y para esto, tenemos que volver a la clase JugadorDeBasquet y sobreescribir el método equals().
Sobreescribiendo este método, podemos decidir cómo se han de comparar dos objetos JugadorDeBasquet para decidir si son equivalentes o no.
Para esta clase, puesto que el único atributo identificativo que tenemos es el nombre del jugador, pues esa será la condición para decidir si son equivalentes o no.
Así que a la clase JugadorDeBasquet le agregamos este método:
1
2
3
4
5
6
7
8
9
10
11
12
@Override
    public boolean equals(Object objeto) {
    	if (objeto instanceof JugadorDeBasquet) {
    		//El objeto recibido como Object, es un JugadorDeBasquet
    		//Hacemos casting a JugadorDeBasquet y vemos si tiene el mismo
    		//nombre que este objeto
    		JugadorDeBasquet otroJugador = (JugadorDeBasquet) objeto;
    		return otroJugador.getNombre().equals(this.nombre);
    	}
    	else //El objeto que comparamos ni siquiera es un JugadorDeBasquet
    		return false;
    }

Con esto, ahora el ArrayList si sabrá comparar JugadoresDeBasquet y determinar si son iguales o no.

Ahora el método másTriples(), vamos a completarlo.
Primero hacer notar que el enunciado es un poco incongruente. Dice que el método ha de imprimir en pantalla el nombre del jugador, así que podemos suponer que es de tipo void. Pero luego habla de retornar un jugador...¿en qué quedamos?

Puesto que lo único que se desea es sacar por pantalla su nombre, yo optaría por no retornar nada y dejarlo como void.
Importante, tú has puesto que reciba por parámetros un array de jugadores.
Este método no necesita recibir nada, tan solo tiene que acceder al ArrayList de JugadorDeBasquet. Y tiene acceso garantizado porque ese ArrayList es un atributo de su clase. Así que no necesita recibir nada.

Basta con recorrer el ArrayList, por ejemplo con un for each.
En una variable guardaremos el máximo de triples encontrado hasta el momento, comienza con valor 0.
En otra, el nombre del jugador que supere ese máximo.

Iremos preguntando por cada jugador si tiene más triples que el máximo actual registrado.
En caso negativo, no hacemos nada y pasamos al siguiente.
En caso afirmativo, guardamos el nombre de este jugador y actualizamos el máximo de triples con el nuevo valor.

Cuando el bucle haya recorrido todos los jugadores, ya tendremos los datos que necesitamos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public void masTriples(){
		int mayorTriples = 0; //Aqui guardaremos las mayores cantidades de triples que encontremos
		String nombreJugador = ""; //Aqui el nombre del jugador que ostenta la mayor cantida de triples
 
		//Recorremos lista de jugadores con un for each
		for (JugadorDeBasquet jugador: jdrB) {
			if (jugador.getCantidadTriples() > mayorTriples) { //¿Este jugador tiene más triples que el anterior?
				nombreJugador = jugador.getNombre(); //Pues guardamos su nombre
				mayorTriples = jugador.getCantidadTriples(); //Y actualizamos el nuevo record de triples
			}
		}
		//Lista ya recorrida, ya deberíamos tener el nombre del jugador con más triples
		System.out.println("El jugador con más triples es " + nombreJugador);
		System.out.println("Total triples convertidos: " + mayorTriples);
	}


Y ya está. La clase EquipoDeBasquet no necesita ningún otro método más, así que se quedaría así:
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 EquipoDeBasquet{
 
	private String nombreEquipo;
	private ArrayList<JugadorDeBasquet> jdrB = new ArrayList<>();
 
	public EquipoDeBasquet(){}
 
	public String getNombreEquipo() {
		return nombreEquipo;
	}
 
	public void setNombreEquipo(String nombreEquipo) {
		this.nombreEquipo = nombreEquipo;
	}
 
	public void incorporarJugadorTitular(JugadorDeBasquet unBasquebolista){
		this.jdrB.add(unBasquebolista);
	}
 
	public boolean eliminarJugadorTitular(JugadorDeBasquet unBasquebolista){
		return jdrB.remove(unBasquebolista);
	}
 
	public void masTriples(){
		int mayorTriples = 0; //Aqui guardaremos las mayores cantidades de triples que encontremos
		String nombreJugador = ""; //Aqui el nombre del jugador que ostenta la mayor cantida de triples
 
		//Recorremos lista de jugadores con un for each
		for (JugadorDeBasquet jugador: jdrB) {
			if (jugador.getCantidadTriples() > mayorTriples) { //¿Este jugador tiene más triples que el anterior?
				nombreJugador = jugador.getNombre(); //Pues guardamos su nombre
				mayorTriples = jugador.getCantidadTriples(); //Y actualizamos el nuevo record de triples
			}
		}
		//Lista ya recorrida, ya deberíamos tener el nombre del jugador con más triples
		System.out.println("El jugador con más triples es " + nombreJugador);
		System.out.println("Total triples convertidos: " + mayorTriples);
	}
 
}


Pasemos al programa principal.
Hay que crear dos equipos, incorporarle jugadores y mostrar cuáles tienen más triples.
Bien, en ningún momento se dice que esto se tenga que hacer por teclado.
Pero supongo que eso lo hace más interesante.

Antes de empezar, puesto que para crear un jugador necesitamos nombre y cantidad de triples, nos puede facilitar la tarea añadirle a la clase JugadorDeBasquet un constructor que reciba estos dos parámetros. Así podemos crear jugadores rápidamente.
Y también otro que solo requiera el nombre. Ambos nos pueden ser útiles.

1
2
3
4
5
6
7
8
9
10
11
12
13
public class JugadorDeBasquet {
 
    private String nombre;
    private int cantidadTriples;
 
    public JugadorDeBasquet(String nombre) {
    	this.nombre = nombre;
    }
 
    public JugadorDeBasquet(String nombre, int triples) {
    	this.nombre = nombre;
    	cantidadTriples = triples;
    }

Lo mismo con EquipoDeBasquet, un constructor que directamente acepte el nombre del equipo:
1
2
3
public EquipoDeBasquet(String nombre){
		nombreEquipo = nombre;
	}

Por otro lado, otra cosa que puede ser interesante contemplar, es que un equipo solo puede tener 5 jugadores titulares. La clase EquipoDeBasquet no está controlando esto, así que se pueden añadir jugadores sin límite.
No debería ser así, y propongo que cambiemos el método incorporarJugadorTitular() a tipo boolean. Y que compruebe cuantos jugadores hay ya incorporados y devuelva false cuando ya se tengan los 5 titulares.

1
2
3
4
5
6
7
8
public boolean incorporarJugadorTitular(JugadorDeBasquet unBasquebolista){
		if (jdrB.size() == 5) //Ya tenemos 5 titulares
			return false;
		else {
			jdrB.add(unBasquebolista);
			return true; //Jugador aceptado
		}
	}


Listo. Ahora podemos meternos con el programa principal.
Hay tres opciones: incorporar, eliminar y mostrar triples.
Bien, de cada opción debería encargarse un método separado.
Y como los dos primeros van a requerir usar el Scanner para leer por teclado, mejor entonces si el Scanner lo declaramos fuera del método main(), para que sea un atributo global y todos los métodos de esta clase puedan acceder a él.
Si lo declaramos dentro del main(), entonces el Scanner solo será visible dentro de este.
Lo mismo con los objetos EquiposDeBasquet, los podemos declarar en el ámbito global, para que tengan plena visibilidad dentro de la clase.


El switch ha de contemplar las tres opciones, también la cuarta opción (que pulse 0 para salir) donde mostraríamos un mensaje indicando el fin del programa y también la posibilidad de que pulse un número no válido (default).

El método para incorporar Jugador ha de pedir nombre, triples y en que equipo quiere incorporarlo.
E informará si se pudo incorporar o no.

El método para eliminar bastará con que pida un nombre. El método intentará eliminarlo del equipo1 y si no es posible, del equipo 2.
E informará si se eliminó, o si no lo ha hecho (porque no lo ha encontrado en ningún equipo.

El método de mostrar triples es muy sencillo. Solo mostrar un par de mensajes en pantalla.

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
public class Principal {
 
	static Scanner entrada = new Scanner(System.in);
	static EquipoDeBasquet equipo1 = new EquipoDeBasquet("Aguilas");
	static EquipoDeBasquet equipo2 = new EquipoDeBasquet("Vampiros");
 
	public static void main(String[]args){
		int opcion;
		do{
			System.out.println("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ");
			System.out.println("    1 - Incorporar Jugador Titular");
			System.out.println("    2 - Eliminar Jugador Titular");
			System.out.println("    3 - Imprimir Jugadores con mas TRIPLES");
			System.out.println("    == INGRESE 0 PARA SALIR DEL PROGRAMA ==");
			System.out.println("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ");
			System.out.print("Opcion: ");
			opcion = Integer.parseInt(entrada.nextLine());
 
			switch(opcion){
			case 1:
				System.out.println("\n    -- INCORPORAR JUGADOR --");
				incorporar();
				break;
 
			case 2:
				System.out.println("    -- ELIMINAR JUGADOR --");
				eliminar();
				break;
 
			case 3:
				System.out.println("    -- IMPRIMIR --");
				masTriples();
				break;
 
			case 0:
				System.out.println("\n\t\tFIN DE PROGRAMA");
				break;
			default:
				System.out.println("No existe la opción indicada.");
			}
		}while(opcion != 0);
	}
 
	/*
	 * Metodo para incorporar jugadores
	 */
	static void incorporar() {
		System.out.print("\nNombre del jugador: ");
		String nombre = entrada.nextLine();
		System.out.print("Triples anotados: ");
		int triples = Integer.parseInt(entrada.nextLine());
		System.out.println("Elija en que equipo incorporarlo:");
		System.out.println("1 - " + equipo1.getNombreEquipo());
		System.out.println("2 - " + equipo2.getNombreEquipo());
		int equipo = Integer.parseInt(entrada.nextLine());
		if (equipo == 1) {
			if (equipo1.incorporarJugadorTitular(new JugadorDeBasquet(nombre, triples)))
				System.out.println("¡¡Jugador incorporado!!\n");
			else
				System.out.println("Jugador rechazado. El equipo ya está completo.\n");
		}
		else {
			if (equipo2.incorporarJugadorTitular(new JugadorDeBasquet(nombre, triples)))
				System.out.println("¡¡Jugador incorporado!!\n");
			else
				System.out.println("Jugador rechazado. El equipo ya está completo.\n");
		}
	}
 
	/*
	 * Método para eliminar jugadores
	 */
	static void eliminar() {
		System.out.print("\nNombre del jugador: ");
		String nombre = entrada.nextLine();
		boolean eliminado = false;
		//Comprobamos si algún equipo puede eliminarlo
		if (equipo1.eliminarJugadorTitular(new JugadorDeBasquet(nombre)) ||
				equipo2.eliminarJugadorTitular(new JugadorDeBasquet(nombre)))
			eliminado = true;
 
		if (eliminado)
			System.out.println("¡¡Jugador eliminado!!");
		else
			System.out.println("No se encontró el jugador en ningún equipo");
	}
 
	/*
	 * Método para imprimir campeones de triples
	 */
	static void masTriples() {
		System.out.println("\nEquipo " + equipo1.getNombreEquipo());
		equipo1.masTriples();
		System.out.println("\nEquipo " + equipo2.getNombreEquipo());
		equipo2.masTriples();
	}
 
}

Y con esto, ya funcionaría todo.
Pruébalo y pregunta lo que no entiendas.

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