Java - llenar un array de objetos y desordenar un array.

 
Vista:
sin imagen de perfil
Val: 41
Ha disminuido 1 puesto en Java (en relación al último mes)
Gráfica de Java

llenar un array de objetos y desordenar un array.

Publicado por Francisco Tomás (14 intervenciones) el 17/11/2019 00:25:01
primero, hola a todos y espero que podais ayudarme.

primera duda:
Tengo un array (string) el cual almacena nombres, y el cual quiero desordenar y utilizar posteriormente, podriais decirme si mi ejemplo es funcional.

Captura


segunda duda:
Quiero llenar mi array(en este caso [99])sin que tenga que rellenarlo el usuario, en este caso cada objeto tendra un nombre(como no se como generar nombres diferentes se ira generando Miguel1,Miguel2,Miguel3...) y una cuenta(que se corresponde con su posicion del array 1,2,3... ,es decir correlativo), sin embargo el resultado a la hora de la ejecución es NULL para todas posiciones. Esta mi logica mal en este caso o simplemente he pasado algo por alto a la hora de generarlo.

Captura1
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 Lawliet
Val: 888
Plata
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

llenar un array de objetos y desordenar un array.

Publicado por Lawliet (303 intervenciones) el 17/11/2019 01:39:34
Hola!!

"primera duda:
Tengo un array (string) el cual almacena nombres, y el cual quiero desordenar y utilizar posteriormente, podriais decirme si mi ejemplo es funcional."


A mi punto de vista yo veo dos escenarios en lo que planteas al momento de desordenar los nombres:

1.- Desordenar los nombres sin importar que estos se repitan.
2.- Desordenar los nombres importando que no se repitan los nombres.

Para ambos escenarios aquí te pongo la solución, como podrás darte cuenta, he comentado el código para explicar un poco el procedimiento.

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
package com.lawliet.home;
 
import java.util.Arrays;
import java.util.Random;
 
public class NombresDesordenados {
 
	public NombresDesordenados() {
		nombresDesornados();
		nombresDesornadosSinRepetir();
	}
 
	public static void main(String[] args) {
		new NombresDesordenados();
	}
 
	private void nombresDesornados() {
		Random random = new Random();											// Declaramos un objeto Random el cual nos permitira crear valores aleatorios.
		String[] nombres = {"Alberto","Francisco","Lawliet","Naruto","Tomas"};	// Declaramos nuestro arreglo de nombres.
		String[] nombresDesordenados = new String[5];							// Declaramos un nuevo arreglo el cual contendrá nuestros nombres desordenados.
		int indice = 0;															// Indice y/o posición que corresponde al nuevo arreglo.
 
		while(indice < 5) {														// Mientras nuestro indice sea menor a 5 siendo el tamaño máximo de nuestro arreglo, haremos lo siguiente.
			int posicion = random.nextInt(nombres.length);						// Generamos un nuevo número aleatorio pasando como valor máximo el tamaño original de nuestro arreglo.
			nombresDesordenados[indice] = nombres[posicion];					// Obtenemos el nombre de nuestro arreglo original según el número aleatorio que creamos y eso lo pasamos a nuestro nuevo arreglo.
			indice++;															// Incrementamos el indice de nuestro nuevo arreglo para llenar las 5 posiciones de nuestro arreglo contado el 0; es decir, 0 - 4.
		}
 
		System.out.print("NOMBRES DESORDENADOS: ");
		System.out.println(Arrays.toString(nombresDesordenados));				// Imprimimos nuestro arreglo final.
	}
 
	private void nombresDesornadosSinRepetir() {
		Random random = new Random();												// Declaramos un objeto Random el cual nos permitira crear valores aleatorios.
		String[] nombres = {"Alberto","Francisco","Lawliet","Naruto","Tomas"};		// Declaramos nuestro arreglo de nombres.
		String[] nombresDesordenados = new String[5];								// Declaramos un nuevo arreglo el cual contendrá nuestros nombres desordenados.
		int indice = 0;																// Indice y/o posición que corresponde al nuevo arreglo.
 
		while(indice < 5) {															// Mientras nuestro indice sea menor a 5 siendo el tamaño máximo de nuestro arreglo, haremos lo siguiente.
			int posicion = random.nextInt(nombres.length);							// Generamos un nuevo número aleatorio pasando como valor máximo el tamaño original de nuestro arreglo.
 
			if(!Arrays.asList(nombresDesordenados).contains(nombres[posicion])) {	// Preguntamos si nuestro arreglo nuevo ya contiene ese nombre, si no existe ese nombre en nuestro nuevo arreglo, lo agregamos, caso contrario no haremos nada. 
				nombresDesordenados[indice] = nombres[posicion];					// Obtenemos el nombre de nuestro arreglo original según el número aleatorio que creamos y eso lo pasamos a nuestro nuevo arreglo.
				indice++;															// Incrementamos el indice de nuestro nuevo arreglo para llenar las 5 posiciones de nuestro arreglo contado el 0; es decir, 0 - 4.
			}
		}
 
		System.out.print("NOMBRES DESORDENADOS SIN REPETIR: ");
		System.out.println(Arrays.toString(nombresDesordenados));					// Imprimimos nuestro arreglo final.
	}
}

Output
1
2
NOMBRES DESORDENADOS: [Lawliet, Naruto, Francisco, Lawliet, Francisco]
NOMBRES DESORDENADOS SIN REPETIR: [Lawliet, Francisco, Alberto, Naruto, Tomas]

"segunda duda:
Quiero llenar mi array(en este caso [99])sin que tenga que rellenarlo el usuario, en este caso cada objeto tendra un nombre(como no se como generar nombres diferentes se ira generando Miguel1,Miguel2,Miguel3...) y una cuenta(que se corresponde con su posicion del array 1,2,3... ,es decir correlativo), sin embargo el resultado a la hora de la ejecución es NULL para todas posiciones. Esta mi logica mal en este caso o simplemente he pasado algo por alto a la hora de generarlo."


Supongo que todo tiene que ver en como llamas el método que te hace el llenado del arreglo, aquí podemos observar que no tuve problemas en hacer lo que necesitas.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.lawliet.home;
 
import java.util.Arrays;
 
import com.lawliet.vo.Cuenta;
 
public class LlenarArregloObjetos {
 
	public static void main(String[] args) {
		Cuenta[] cuentas = new Cuenta[99];
 
		for(int i = 0; i < cuentas.length; i++) {
			cuentas[i] = new Cuenta("Miguel" + i, i);
		}
 
		System.out.println(Arrays.toString(cuentas));
	}
}

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
package com.lawliet.vo;
 
public class Cuenta {
 
	private String nombre;
	private int cuenta;
 
	public Cuenta(String nombre, int cuenta) {
		this.nombre = nombre;
		this.cuenta = cuenta;
	}
 
	public String getNombre() {
		return nombre;
	}
 
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}
 
	public int getCuenta() {
		return cuenta;
	}
 
	public void setCuenta(int cuenta) {
		this.cuenta = cuenta;
	}
 
	@Override
	public String toString() {
		return "Cuenta [nombre=" + nombre + ", cuenta=" + cuenta + "]";
	}
}

Output
1
[Cuenta [nombre=Miguel0, cuenta=0], Cuenta [nombre=Miguel1, cuenta=1], Cuenta [nombre=Miguel2, cuenta=2], Cuenta [nombre=Miguel3, cuenta=3], Cuenta [nombre=Miguel4, cuenta=4], Cuenta [nombre=Miguel5, cuenta=5], Cuenta [nombre=Miguel6, cuenta=6], Cuenta [nombre=Miguel7, cuenta=7], Cuenta [nombre=Miguel8, cuenta=8], Cuenta [nombre=Miguel9, cuenta=9], Cuenta [nombre=Miguel10, cuenta=10], Cuenta [nombre=Miguel11, cuenta=11], Cuenta [nombre=Miguel12, cuenta=12], Cuenta [nombre=Miguel13, cuenta=13], Cuenta [nombre=Miguel14, cuenta=14], Cuenta [nombre=Miguel15, cuenta=15], Cuenta [nombre=Miguel16, cuenta=16], Cuenta [nombre=Miguel17, cuenta=17], Cuenta [nombre=Miguel18, cuenta=18], Cuenta [nombre=Miguel19, cuenta=19], Cuenta [nombre=Miguel20, cuenta=20], Cuenta [nombre=Miguel21, cuenta=21], Cuenta [nombre=Miguel22, cuenta=22], Cuenta [nombre=Miguel23, cuenta=23], Cuenta [nombre=Miguel24, cuenta=24], Cuenta [nombre=Miguel25, cuenta=25], Cuenta [nombre=Miguel26, cuenta=26], Cuenta [nombre=Miguel27, cuenta=27], Cuenta [nombre=Miguel28, cuenta=28], Cuenta [nombre=Miguel29, cuenta=29], Cuenta [nombre=Miguel30, cuenta=30], Cuenta [nombre=Miguel31, cuenta=31], Cuenta [nombre=Miguel32, cuenta=32], Cuenta [nombre=Miguel33, cuenta=33], Cuenta [nombre=Miguel34, cuenta=34], Cuenta [nombre=Miguel35, cuenta=35], Cuenta [nombre=Miguel36, cuenta=36], Cuenta [nombre=Miguel37, cuenta=37], Cuenta [nombre=Miguel38, cuenta=38], Cuenta [nombre=Miguel39, cuenta=39], Cuenta [nombre=Miguel40, cuenta=40], Cuenta [nombre=Miguel41, cuenta=41], Cuenta [nombre=Miguel42, cuenta=42], Cuenta [nombre=Miguel43, cuenta=43], Cuenta [nombre=Miguel44, cuenta=44], Cuenta [nombre=Miguel45, cuenta=45], Cuenta [nombre=Miguel46, cuenta=46], Cuenta [nombre=Miguel47, cuenta=47], Cuenta [nombre=Miguel48, cuenta=48], Cuenta [nombre=Miguel49, cuenta=49], Cuenta [nombre=Miguel50, cuenta=50], Cuenta [nombre=Miguel51, cuenta=51], Cuenta [nombre=Miguel52, cuenta=52], Cuenta [nombre=Miguel53, cuenta=53], Cuenta [nombre=Miguel54, cuenta=54], Cuenta [nombre=Miguel55, cuenta=55], Cuenta [nombre=Miguel56, cuenta=56], Cuenta [nombre=Miguel57, cuenta=57], Cuenta [nombre=Miguel58, cuenta=58], Cuenta [nombre=Miguel59, cuenta=59], Cuenta [nombre=Miguel60, cuenta=60], Cuenta [nombre=Miguel61, cuenta=61], Cuenta [nombre=Miguel62, cuenta=62], Cuenta [nombre=Miguel63, cuenta=63], Cuenta [nombre=Miguel64, cuenta=64], Cuenta [nombre=Miguel65, cuenta=65], Cuenta [nombre=Miguel66, cuenta=66], Cuenta [nombre=Miguel67, cuenta=67], Cuenta [nombre=Miguel68, cuenta=68], Cuenta [nombre=Miguel69, cuenta=69], Cuenta [nombre=Miguel70, cuenta=70], Cuenta [nombre=Miguel71, cuenta=71], Cuenta [nombre=Miguel72, cuenta=72], Cuenta [nombre=Miguel73, cuenta=73], Cuenta [nombre=Miguel74, cuenta=74], Cuenta [nombre=Miguel75, cuenta=75], Cuenta [nombre=Miguel76, cuenta=76], Cuenta [nombre=Miguel77, cuenta=77], Cuenta [nombre=Miguel78, cuenta=78], Cuenta [nombre=Miguel79, cuenta=79], Cuenta [nombre=Miguel80, cuenta=80], Cuenta [nombre=Miguel81, cuenta=81], Cuenta [nombre=Miguel82, cuenta=82], Cuenta [nombre=Miguel83, cuenta=83], Cuenta [nombre=Miguel84, cuenta=84], Cuenta [nombre=Miguel85, cuenta=85], Cuenta [nombre=Miguel86, cuenta=86], Cuenta [nombre=Miguel87, cuenta=87], Cuenta [nombre=Miguel88, cuenta=88], Cuenta [nombre=Miguel89, cuenta=89], Cuenta [nombre=Miguel90, cuenta=90], Cuenta [nombre=Miguel91, cuenta=91], Cuenta [nombre=Miguel92, cuenta=92], Cuenta [nombre=Miguel93, cuenta=93], Cuenta [nombre=Miguel94, cuenta=94], Cuenta [nombre=Miguel95, cuenta=95], Cuenta [nombre=Miguel96, cuenta=96], Cuenta [nombre=Miguel97, cuenta=97], Cuenta [nombre=Miguel98, cuenta=98]]

Sin más que comentar, quedo al pendiente de cualquier duda y/o comentario.

Saludos!
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
sin imagen de perfil
Val: 41
Ha disminuido 1 puesto en Java (en relación al último mes)
Gráfica de Java

llenar un array de objetos y desordenar un array.

Publicado por Francisco Tomás (14 intervenciones) el 17/11/2019 13:57:35
Muchisimas gracias por tu ayuda, gracias por este trabajazo, he solucionado ambas dudas.

Ya de paso me gustaria tratar otra duda, esta se puede decir que es general del funcionamiento de mi programa por lo que para ayudarme tendrá uno que entender lo que intento hacer, es decir que puede ser mucho(aunque por supuesto mi programa no es tan largo ni complicado), pero si os tomaís la molestía lo agradecere muchisimo.

Explicación breve:
Yo tengo cuatro clases"Pasajero,Pasajeros,Avión y Main.

En la clase Pasajero tengo lo siguiente.


Imagen

Imagen1

Simplemente una declaración de atributos.

En la clase Pasajeros, la cual Representa al conjunto de pasajeros están los siguientes métodos.


Imagen2

Imagen3PNG

En la clase Avión empiezan mis problemas, lo que quiero que haga esta clase es lo siguiente:

La función de la clase avión consistirá en embarcar a los pasajeros y comprobar si tienen tarjeta de embarque, en caso de no tenerla buscará un nuevo asiento aleatorio que esté libre. Por otro lado, si el pasajero tiene tarjeta de embarque y su asiento está ocupado por una persona que se ha sentado previamente también deberá buscar otro asiento libre de forma aleatoria.
Finalmente, cuando se mire el último pasajero nos mostrará por pantalla si su (el que tiene en la tarjeta de embarque) coincide con el último asiento libre.
de momento en la clase tengo esto:
Imagen4


En el main se que debo crear los los diferentes pasajeros y el avión.

Despues de haberlos creado desordeno la lista y asigno al pasajero que se encuentra en la posición 0 la tarjeta de embarque perdida.
Y esta es la que luego le paso a la función embarque de la clase Avion.
Sin embargo, en este punto tengo un array de objetos, y no se como tratar a estos objetos , le paso este array a la clase pasajero con el fin introducirlo al metodo desordenar?.

Imagen5

En fin, se que la pregunta es muy general y practicamente tienes que resolver el ejercio, pero yo me he quedado atascado aqui.
Si alguien me ayuda o da indicaciones de por donde ir lo agradecere muchisimo, sino cuando lo resuelva publicare mi resultado por si a alguien le resultara de ayuda alguna vez.

Gracias de anteno y un saludo a todos.
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