Java - como puedo ordenar el resultado de esta clase que es un sorteo en java

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

como puedo ordenar el resultado de esta clase que es un sorteo en java

Publicado por manuel (17 intervenciones) el 23/05/2021 08:03:46
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
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
 
import javax.swing.JOptionPane;
 
public class Sorteo implements Comparable<Sorteo> {
 
	@SuppressWarnings({ "unchecked", "rawtypes" })
	private ArrayList<String> usuarios= new ArrayList();
	@SuppressWarnings({ "rawtypes", "unchecked" })
	private ArrayList<String> premios= new ArrayList();
	private ArrayList<Repartido> asignacion = new ArrayList<>();
 
 
 
	public String usuario(){
 
		if(this.usuarios.isEmpty()) {
			return null;
		}else {
			int numero = (int) (Math.random() * this.usuarios.size());
			String u = this.usuarios.get(numero);
			this.usuarios.remove(numero);
			return u;
		}
 
	}
 
	public String premio(){
		if(this.premios.isEmpty()) {
			return null;
		}else {
			int numero = (int) (Math.random() * this.premios.size());
			String p = this.premios.get(numero);
			this.premios.remove(numero);
			return p;
		}
 
	}
 
	public void addUsuario(String u){
		this.usuarios.add(u);
	}
 
	public void addPremio(String p){
		this.premios.add(p);
	}
 
	public void sortear(){
 
 
 
		if(!(this.usuarios.size()==0 || this.premios.size()==0)) {
 
			this.asignacion.clear();
 
			while(this.usuarios.size()!=0 && this.premios.size()!=0){
				String u = this.usuario();
				String p = this.premio();
				this.asignacion.add(new Repartido(u, p));
			}
		}
 
 
		/*String sorteado = "";
		for(int i=0; i<this.asignacion.size();i++){
			sorteado = sorteado + this.asignacion.get(i).getUsr() + " : " + this.asignacion.get(i).getPrm() + "\n";
		}
		return sorteado;*/
	}
 
	public boolean eliminarU(String user){
		for(int i = 0; i<this.usuarios.size(); i++){
			if(this.usuarios.get(i).equals(user)){
				this.usuarios.remove(i);
				return true;
			}
		}
		return false;
	}
 
	public boolean eliminarP(String premio){
		for(int i = 0; i<this.premios.size(); i++){
			if(this.premios.get(i).equals(premio)){
				this.premios.remove(i);
				return true;
			}
		}
		return false;
	}
 
	public void vaciar(){
		this.usuarios.clear();
		this.premios.clear();
		this.asignacion.clear();
	}
 
	public String mostrarU(){
		String u = "";
		for(int i=0; i<this.usuarios.size(); i++){
			u += this.usuarios.get(i) + "\n";
		}
		return u;
	}
 
	public String mostrarP(){
		String p = "";
		for(int i=0; i<this.premios.size(); i++){
			p += this.premios.get(i) + "\n";
		}
		return p;
	}
 
	public void guardarResultado(String nombreFich) throws FileNotFoundException, IOException, ClassNotFoundException{
 
		    File f = new File(nombreFich);
		    FileWriter fw = new FileWriter(f);
		    BufferedWriter escritura = new BufferedWriter(fw);
		    escritura.write("RESULTADO DEL SORTEO Voluntariado 2021");
	        escritura.newLine();
		    escritura.write("---------------------------------------");
	        escritura.newLine();
		    for(int i=0;i<this.asignacion.size();i++){
		        escritura.write(asignacion.get(i).toString());
		        escritura.newLine();
		    }
		    escritura.close();
		}
	public void verNombres (String nombreFich) throws IOException {
		 File f = new File(nombreFich);
		    FileWriter fw = new FileWriter(f);
		    BufferedWriter escritura = new BufferedWriter(fw);
		    escritura.write("Relacion de Nombres Guardados");
	        escritura.newLine();
		    escritura.write("--------------------");
	        escritura.newLine();
		    for(int i=0;i<this.usuarios.size();i++){
		        escritura.write(usuarios.get(i).toString());
		        escritura.newLine();
		    }
		    escritura.close();
	}
		   public void verParcelas (String nombreFich) throws IOException {
				 File f = new File(nombreFich);
				    FileWriter fw = new FileWriter(f);
				    BufferedWriter escritura = new BufferedWriter(fw);
				    escritura.write("Relacion de Posiciones Guardadas");
			        escritura.newLine();
				    escritura.write("--------------------");
			        escritura.newLine();
				    for(int i=0;i<this.premios.size();i++){
				        escritura.write(premios.get(i).toString());
				        escritura.newLine();
				    }
				    escritura.close();
	}
 
	public void guardarNombres(String nombreFich) {
 
		try{
	         FileOutputStream fos= new FileOutputStream(nombreFich);
	         ObjectOutputStream oos= new ObjectOutputStream(fos);
 
	         oos.writeObject(usuarios);
	         oos.close();
	         fos.close();
	       }catch(IOException ioe){
	            ioe.printStackTrace();
	        }
		}
 
 
	public void cargarNombres(String nombreFich) {
 
		ArrayList<String> usuariosFichero = new ArrayList<>();
 
		try
        {
            FileInputStream fis = new FileInputStream(nombreFich);
            ObjectInputStream ois = new ObjectInputStream(fis);
            usuariosFichero = (ArrayList) ois.readObject();
            ois.close();
            fis.close();
         }catch(IOException ioe){
             ioe.printStackTrace();
             return;
          }catch(ClassNotFoundException c){
             System.out.println("Class not found");
             c.printStackTrace();
             return;
          }
 
        for(String tmp: usuariosFichero){
 
        	if(!usuarios.contains(tmp)) {
        		usuarios.add(tmp);
        	}
        }
	}
	public void guardarParcelas(String nombreFich1) {
 
		try{
	         FileOutputStream fos1= new FileOutputStream(nombreFich1);
	         ObjectOutputStream oos1= new ObjectOutputStream(fos1);
 
	         oos1.writeObject(premios);
	         oos1.close();
	         fos1.close();
	       }catch(IOException ioe){
	            ioe.printStackTrace();
	        }
		}
 
 
 
 
 
        public void cargarParcelas(String nombreFich1) {
 
    		ArrayList<String> parcelasFichero = new ArrayList<>();
 
    		try
            {
                FileInputStream fis1 = new FileInputStream(nombreFich1);
                ObjectInputStream ois1 = new ObjectInputStream(fis1);
                parcelasFichero = (ArrayList) ois1.readObject();
                ois1.close();
                fis1.close();
             }catch(IOException ioe){
                 ioe.printStackTrace();
                 return;
              }catch(ClassNotFoundException c){
                 System.out.println("Class not found");
                 c.printStackTrace();
                 return;
              }
 
            for(String tmp: parcelasFichero){
 
            	if(!premios.contains(tmp)) {
            		premios.add(tmp);
            	}
            }
 
 
 
	}
 
	public ArrayList<String> getUsuarios() {
		return usuarios;
	}
 
	public void setUsuarios(ArrayList<String> usuarios) {
		this.usuarios = usuarios;
	}
	public void eliminarNombres() {
 
	}
	public ArrayList<String>getPremios(){
		return premios;
	}
 
	public ArrayList<String>getAsignacion(){
 
		ArrayList<String> resultado = new ArrayList<>();
 
		for (int i = 0; i < asignacion.size(); i++) {
 
			resultado.add(asignacion.get(i).toString());
 
		}
 
 
		return resultado;
	}
 
	@Override
	public int compareTo(Sorteo o) {
		if(o.getPremios()>usuarios) {
			return -1;
		}else if(o.getPremios()==premios) {
			return 0;
		}else {
			return 1;
		}
 
 
	}
}

Necisto ordenar el resultado por orden de premios de meno a mayor
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

como puedo ordenar el resultado de esta clase que es un sorteo en java

Publicado por Kabuto (978 intervenciones) el 23/05/2021 12:29:29
Implementar la interfaz Comparable tal y como lo has hecho, no te va a servir.
Porque se la implementas a la clase Sorteo, por tanto, eso te permitiría comparar un Sorteo con otro Sorteo..., pero tú lo que quieres es comparar Premios.

Bueno, en realidad no tengo muy claro qué es lo que si quiere comparar, porque no tengo claro como se están organizando los datos.

Veo usuarios (String), premios (String) y una clase llamada Repartido que parecer ser que relaciona a un usuario con un premio.
Parece que quien debería implementar la interfaz Comparable, sería la clase Repartido, no Sorteo

¿Y cómo debe compararse un Repartido con otro Repartido?

Pues no lo se..., ¿un usuario solo puede recibir un premio? ¿Puede recibir varios?

Cuando dices:
1
Necisto ordenar el resultado por orden de premios de meno a mayor

¿Menor a mayor qué?

¿Cantidad de premios que tiene un usuario? Si es que puede recibir más de uno...

¿O si no qué? Creo entender que se sortean parcelas, no estoy seguro... pero si son parcelas, ¿Cómo sabemos si una parcela es mayor o menor que otra?
Estos premios/parcela están almacenados en un String. ¿Qué pondría en ese String? ¿Nombre de Parcela y tamaño en m2? En ese caso habría que busca en el String los caracteres que indican el tamaño y transformarlos a valores numéricos para poder comparar.

Pero entonces,, ¿no sería más cómodo crear una clase Premio (o Parcela) con los atributos nombre y tamaño?


Intenta clarificarnos mejor en qué consiste el sorteo, que es lo que se está sorteando y/o si puedes, publica el enunciado del ejercicio.

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
sin imagen de perfil
Val: 53
Ha aumentado su posición en 133 puestos en Java (en relación al último mes)
Gráfica de Java

como puedo ordenar el resultado de esta clase que es un sorteo en java

Publicado por manuel (17 intervenciones) el 23/05/2021 13:29:05
El programa sorteo un numero de parcela con un nombre, lo que quiero hacer que cuando ejecutamos el sorteo y mezcla los nombres con los premios ordenar el resultado por el numero de parcela

Ejemplo de un resultado:

Manuel: 2
Javier:1
Ana: 3

seria que me saliera ordenado por el numero de premio o parcela. Tendríamos unos 50 nombres y del 1 al 50 en premios
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

como puedo ordenar el resultado de esta clase que es un sorteo en java

Publicado por Kabuto (978 intervenciones) el 23/05/2021 23:00:05
Vale en ese caso, como dije, lo más fácil es que sea la clase Repartido quien incorpore la interfaz Comparable.
Al implementar esta interfaz, hay que sobreescribir el método compareTo() que recibirá otro objeto Repartido y hemos de decirle como ha de compararse.

Lo que le diremos es que transforme a Integer los String que contienen los premios(parcelas), para poder hacer una comparación numérica.

La clase Integer incorpora su propio método compareTo(), es decir, ya sabe como ha de compararse con otros enteros, así que ahora simplemente hay que retornar el resultado de comparar los Integer con los números de parcelas.

La clase Repartido, más o menos, podría ser esta:
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
public class Repartido implements Comparable<Repartido> {
 
    private String usuario;
    private String premio;
 
    public Repartido(String usu, String prem) {
        usuario = usu;
        premio = prem;
    }
 
    public String getUsuario() {
        return usuario;
    }
 
    public String getPremio() {
        return premio;
    }
 
    @Override
    public int compareTo(Repartido otroRep) {
        //Transformamos de String a valores numéricos las parcelas
        Integer estaParcela = Integer.parseInt(premio);
        Integer otraParcela = Intege.parseInt(otroRep.getPremio());
        //Los objetos Integer saben cómo compararse ellos mismos, retornamos el resultado de comparar parcelas
        return estaParcela.compareTo(otraParcela);
    }
}

Bien ahora la clase Repartido ya sabe como ha de compararse para ordenarse según el número de parcela.

¿Cómo hacemos efectivo este ordenamiento?

Los objetos Repartido están guardados en este ArrayList llamado "asignacion":
1
private ArrayList<Repartido> asignacion

Pues entonces, cuando queramos que se ordenen antes de escribirlo en un archivo, mostrarlo en pantalla o lo que sea.... lo que hacemos es invocar el método sort() en este ArrayList y le pasamos como parámetro un valor null:

1
asignacion.sort(null);

Con sort() pedimos al ArrayList que ordene sus elementos, y entre paréntesis podemos pasarle un objeto Comparator para indicarle las reglas que ha de seguir para ordenarse.
Si le pasamos un valor null, entonces aplicará las reglas que hayamos escrito dentro de la clase Repartido, que es lo que necesitamos que haga.

Después de haber llamado a este sort(), ya podemos escribir los elementos en fichero o pantalla, que saldrán ordenados por número de parcela.
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: 53
Ha aumentado su posición en 133 puestos en Java (en relación al último mes)
Gráfica de Java

como puedo ordenar el resultado de esta clase que es un sorteo en java

Publicado por manuel (17 intervenciones) el 24/05/2021 07:38:15
Esta es la clase Repartido como quedaria:

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
public class Repartido implements Comparable<Repartido> {
 
	private String usr;
	private String prm;
 
	public Repartido(String u, String p){
		this.usr = u;
		this.prm = p;
	}
 
	public String getUsr() {
		return usr;
	}
	public void setUsr(String usr) {
		this.usr = usr;
	}
	public String getPrm() {
		return prm;
	}
	public void setPrm(String prm) {
		this.prm = prm;
	}
 
	public String toString() {
		return (this.usr+":  "+this.prm);
	}
 
	@Override
    public int compareTo(Repartido otroRep) {
        //Transformamos de String a valores numéricos las parcelas
        Integer estaParcela = Integer.parseInt(prm);
        Integer otraParcela = Integer.parseInt(otroRep.getPrm());
        //Los objetos Integer saben cómo compararse ellos mismos, retornamos el resultado de comparar parcelas
        return estaParcela.compareTo(otraParcela);
    }


Me funciona, pero si ahora si en las posiciones le meto por Ejemplo R-1 que seria el primer reserva que apareciera después de los numeros enteros como lo podría hacer, muchas gracias por todo
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: 53
Ha aumentado su posición en 133 puestos en Java (en relación al último mes)
Gráfica de Java

como puedo ordenar el resultado de esta clase que es un sorteo en java

Publicado por manuel (17 intervenciones) el 24/05/2021 10:03:04
He conseguido que funcione de esta manera, si tiene algún método mejor me comentas, muchas gracias por la ayuda

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Override
    public int compareTo (Repartido otroRep) {
 
		int valordevuelto;
		if(prm.compareTo(otroRep.getPrm())>0) {
			valordevuelto = 1;
		}else if(prm.compareTo(otroRep.getPrm())<0) {
			valordevuelto = -1;
		}else {
			valordevuelto=0;
        return valordevuelto;
		}
		return valordevuelto;
	}
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

como puedo ordenar el resultado de esta clase que es un sorteo en java

Publicado por Kabuto (978 intervenciones) el 24/05/2021 12:33:10
1
Me funciona, pero si ahora si en las posiciones le meto por Ejemplo R-1 que seria el primer reserva que apareciera después de los numeros enteros como lo podría hacer, muchas gracias por todo

Vale, yo el ejemplo que puse fue pensando que solo serían valores numéricos.
Si van a ser valores alfanuméricos (letras y números) puedes hacer lo mismo pero sin convertir a Integer.

El método que has puesto comparando los String "premio" es correcto, pero puedes simplificarlo así:
1
2
3
4
@Override
    public int compareTo(Repartido otroRep) {
        return prm.compareTo(otroRep.getPrm());
    }

Tú lo que haces es:
"si la comparación de estos String me devuelve un valor positivo, retorno un positivo".
"si no, si la comparación me devuelve un valor negativo, retorno un negativo"
"si no, es que la comparación de String me ha devuelto un 0, entonces retorno un 0"


Yo lo que hago es:
"retorno directamente lo que me devuelva la comparación de estos String"

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
1
Comentar
sin imagen de perfil
Val: 53
Ha aumentado su posición en 133 puestos en Java (en relación al último mes)
Gráfica de Java

como puedo ordenar el resultado de esta clase que es un sorteo en java

Publicado por manuel (17 intervenciones) el 24/05/2021 14:03:07
Otra cosita por fa, quiere poner de fondo una fotografia para que el panel quede mejor. Como me recomiendas que lo haga, gracias
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

como puedo ordenar el resultado de esta clase que es un sorteo en java

Publicado por Kabuto (978 intervenciones) el 24/05/2021 21:29:25
Mira, te pongo un ejemplo muy simple.

Primero, una clase JPanel con un atributo Image y por su constructor recibirá un String con la ruta donde se encuentre la imagen que queremos poner de fondo.

En el constructor, usando ese String, creamos el objeto Image que se usará como fondo.

Por último, hay que sobreescribirle método paint().
Este método es el que indica como se ha de "pintar" (mostrar en pantalla) el JPanel.
Aquí lo que le diremos es que dibuje la imagen que hemos creado como atributo.

Este método se autoejecuta cada vez que la ventana cambia su contenido, o si el usuario cambia sus dimensiones. Así que le pediremos que pinte la imagen drawImage() según el ancho y alto actual de la ventana.
Así el fondo se adaptará siempre al tamaño de la ventana aunque cambie durante la ejecución del programa.
Además, hay que eliminar la "opacidad" del panel, de lo contrario, no se verá la imagen.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.awt.Graphics;
import java.awt.Image;
 
import javax.swing.ImageIcon;
import javax.swing.JPanel;
 
public class PanelConFondo extends JPanel{
 
	private Image imagen;
 
	public PanelConFondo(String rutaImagen) {
		imagen = new ImageIcon(getClass().getClassLoader().getResource(rutaImagen)).getImage();
	}
 
	@Override
	public void paint(Graphics g){
		g.drawImage(imagen, 0, 0, getWidth(), getHeight(), this);
		setOpaque(false);
		super.paint(g);
	}
 
}


Bien, ahora crearé la clase principal, un JFrame que usará como contenedor principal un PanelConFondo, la clase que acabamos de escribir.
Al inicializar el objeto PanelConFondo, es cuando le paso la ruta/url donde se encuentra la imagen que quiero usar.
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
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
 
public class Main extends JFrame{
 
	private PanelConFondo panelFondo;
 
	public Main() {
 
		panelFondo = new PanelConFondo("img/fondo.jpg");
 
		setContentPane(panelFondo);
 
		setTitle("Panel Fondo");
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setSize(256, 256);
		setLocationRelativeTo(null);
		setVisible(true);
	}
 
	public static void main(String[] args) {
		SwingUtilities.invokeLater(new Runnable() {
 
			@Override
			public void run() {
				new Main();
			}
		});
	}
 
}


Dicha imagen, lo ideal, es crear dentro del proyecto un package para poner la/s imagen/es que queremos usar.
Yo lo he llamado img, pero se le puede poner cualquier nombre:


imagen_2021-05-24_211450

Y ya está, si ejecutamos el programa, se mostrará el panel con el fondo que hayamos escogido.

imagen_2021-05-24_211648

Si redimensionamos la ventana, la imagen se irá adaptando, aunque lógicamente, sufrirá una deformación al perderse la relación de aspecto.

imagen_2021-05-24_211816

Así que conviene escoger una imagen que no se vuelva muy fea al deformarse, o configurar el JFrame para que no pueda redimensionarse:
setResizable(false);

Además, si el fondo es demasiado pintoresco, como el que he escogido yo, algunos controles Swing pueden quedar poco legibles, especialmente los JLabel

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public Main() {
 
		panelFondo = new PanelConFondo("img/fondo.jpg");
 
		setContentPane(panelFondo);
 
		JLabel texto = new JLabel("Esto es un texto");
		add(texto);
 
		setTitle("Panel Fondo");
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setSize(256, 256);
		setLocationRelativeTo(null);
		setVisible(true);
	}

imagen_2021-05-24_212326

En este caso, podemos activar la opacidad de estos elementos. O tal vez incluso cambiar el color background y el color de texto (foreground)
Ya depende de cada caso.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public Main() {
 
		panelFondo = new PanelConFondo("img/fondo.jpg");
 
		setContentPane(panelFondo);
 
		JLabel texto = new JLabel("Esto es un texto");
		texto.setOpaque(true);
		add(texto);
 
		setTitle("Panel Fondo");
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setSize(256, 256);
		setLocationRelativeTo(null);
		setVisible(true);
	}

imagen_2021-05-24_212612



En fin, esto es solo un ejemplo, que puedes aplicar a cualquier panel.
Solo necesitas añadirle un atributo Image, indicarle la ruta de la imagen (ya sea por constructor o escribiendo directamente la ruta en la propia clase) y pedirle al método paint() que "pinte" la imagen en el panel.

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
2
Comentar
sin imagen de perfil
Val: 53
Ha aumentado su posición en 133 puestos en Java (en relación al último mes)
Gráfica de Java

como puedo ordenar el resultado de esta clase que es un sorteo en java

Publicado por manuel (17 intervenciones) el 07/06/2021 11:04:05
El problema que tengo que cuando saca el resultado empieza 1 y sigue con 10 11 12 hasta 19 luego 2 y sigue 21 22 23 hasta 29 y asi sucesivamente, no me los ordenas de menor a mayor
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: 53
Ha aumentado su posición en 133 puestos en Java (en relación al último mes)
Gráfica de Java

como puedo ordenar el resultado de esta clase que es un sorteo en java

Publicado por manuel (17 intervenciones) el 07/06/2021 09:38:59
Perdona una cosa cuando meto los datos para el sorteo y los numeros con dos ditios me los mezcla. Un ejemplo realizco un sorteo del 1 al 9 y de R-1 al R-9 y no hay problema me salen ordenados pero si metos numeros de dos digitos me los mezcla, por que seria, gracias
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

como puedo ordenar el resultado de esta clase que es un sorteo en java

Publicado por Kabuto (978 intervenciones) el 07/06/2021 12:24:02
Recuerda esto que dije en un mensaje anterior:
1
2
Vale, yo el ejemplo que puse fue pensando que solo serían valores numéricos.
Si van a ser valores alfanuméricos (letras y números) puedes hacer lo mismo pero sin convertir a Integer.

Los valores numéricos, se ordenan de forma distinta que los alfanuméricos.
Supongamos estos valores:

1
3,10,7,8,9,1,4,5,2,6

Si los tratamos como números (int/Integer), y los ordenamos, quedarán así:
1
1,2,3,4,5,6,7,8,9,10
Porque son magnitudes aritméticas y se ordenan de forma numérica, es decir, según el valor de la magnitud que representan.

Pero, si los tratamos como alfanuméricos(String), al ordenar quedan así:
1
1,10,2,3,4,5,6,7,8,9
Porque ya no son magnitudes aritméticas, son caracteres de texto, y entonces se ordenan de forma lexicográfica.
Que si leemos la definición de esta palabreja, es posible que nos estalle el cerebro, pero podemos resumirlo en que aquí el orden se hace igual que las palabras de un diccionario.
Primero las palabras que empiezan por A, luego las que empiezan por B, luego las que empiezan por C, etc..

Y con los números (alfanúmeros en este caso) ocurre lo mismo. Primero los que empiezan por 1, luego los que empiezan por 2, luego los que empiezan por 3...

Así que por ejemplo entre el 1 y el 2, puede ir el 10, el 1000, el 1000000000000, y todas las infinitas cifras que comienzan por 1.

Y si mezclamos letras con números, la cosa se complica más.

La parcela A-333 al ordenar quedará por delante de la B-10.

O la B-010 quedará por delante de la B-10.., aunque el valor del número es el mismo, pero como hemos dicho, esto es texto, no son magnitudes aritméticas


Aclarado esto, ahora tienes que decidir un formato concreto para los números de parcela y de qué forma quieres ordenarlos.
Será más fácil si estableces un formato, por ejemplo:
1
2
3
"letra guión número" --> G-45
"letra número" --> G45
"solo número" --> 45

Porque así sabrás con certeza cómo es la cadena que vas a recibir y tendrás más claro como operar con ella para ordenar.
Y luego, decidir como ordenar.
Si quieres que la letra no importe, y que el orden solo sea por el valor numérico:
1
2
3
G-45
B-50
G-410
O si quieres un orden lexicográfico (que es como se ordenan los String por defecto):
1
2
3
B-45
G-410
G-45

O si quieres que se ordenen según la letra (si es que decides un formato con letra), y luego además, por valor numérico
1
2
3
B-45
G-45
G-410


Este último ordenamiento, parece el más lógico, pero también puede ser un poco (solo un poco) más difícil de conseguir porque en este caso, en el compareTo(), habría que establecer un condicional:
1
2
3
4
5
6
7
Si los números de parcela comienzan por letras distintas
    extraer de las cadenas letras de inicio
     retornar resultado comparar letras
si no, si los números de parcela son la misma letra
     extraer de las cadenas los caracteres numéricos
     convertir a int
     retornar resultado comparar los valores int


Si decidieras no establecer un formato, si no que las parcelas pueden ser cadenas de solo números pero también cadenas que comiencen por letra y luego números, también se puede hacer.
Pero habrá que añadir un poco más de código (solo un poco) para identificar que tipos de cadenas se han recibido y decidir como han de ser comparadas.

Pues eso, lo primero, decidir si quieres fijar un formato para los números de parcela, y cuál sería ese formato.
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: 53
Ha aumentado su posición en 133 puestos en Java (en relación al último mes)
Gráfica de Java

como puedo ordenar el resultado de esta clase que es un sorteo en java

Publicado por manuel (17 intervenciones) el 07/06/2021 12:26:18
Lo que tengo que sortear ahora es del 1 al 24 y del R-1 AL R-22, si fuera posible me ayudaras con ese codigo, gracias
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

como puedo ordenar el resultado de esta clase que es un sorteo en java

Publicado por Kabuto (978 intervenciones) el 07/06/2021 12:32:13
No importa qué se sortea.
Lo que importa es cómo queremos que se ordene.

¿El 2 va delante o detrás del R-1?

1
1,R-1,2,R-2

O sería
1
1,2,R-1,R-2

O...
1
R-1,R-2,1,2
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: 53
Ha aumentado su posición en 133 puestos en Java (en relación al último mes)
Gráfica de Java

como puedo ordenar el resultado de esta clase que es un sorteo en java

Publicado por manuel (17 intervenciones) el 07/06/2021 12:34:26
primero seria los numeros y luego las R que seria los reservas en orden por numeracion de reserva
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: 53
Ha aumentado su posición en 133 puestos en Java (en relación al último mes)
Gráfica de Java

como puedo ordenar el resultado de esta clase que es un sorteo en java

Publicado por manuel (17 intervenciones) el 07/06/2021 12:35:27
seria la opcion dos que me das
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

como puedo ordenar el resultado de esta clase que es un sorteo en java

Publicado por Kabuto (978 intervenciones) el 08/06/2021 01:53:58
OK.
Para que se vea la diferencia he hecho una pequeña muestra de premios.
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
public class Prueba {
 
	private static ArrayList<Repartido> premios = new ArrayList<Repartido>();
 
	public static void main(String[] args) {
 
		//Llenado de prueba
		premios.add(new Repartido("User", "24"));
		premios.add(new Repartido("User", "2"));
		premios.add(new Repartido("User", "R-22"));
		premios.add(new Repartido("User", "R-10"));
		premios.add(new Repartido("User", "8"));
		premios.add(new Repartido("User", "6"));
		premios.add(new Repartido("User", "R-2"));
		premios.add(new Repartido("User", "R-1"));
		premios.add(new Repartido("User", "22"));
 
		//Ordenamiento
		premios.sort(null);
 
		//Mostrar en pantalla
		for (Repartido rep: premios)
			System.out.println(rep.getPremio());
 
	}
 
}

Si hacemos un ordenamiento lexicográfico, es decir, simplemente comparar los String tal cual, si quedan primero los premios sin letra y luego los premios con letra.
Pero no en el orden numérico que nos gustaría:
1
2
3
4
5
6
7
8
2
22
24
6
8
R-1
R-10
R-2

¿Qué lógica necesitaremos codificar pues en el compareTo()?

Bien, hay que detectar los posibles escenarios que vamos encontrar. Y son tres:


- 1 Ambas cadenas son NUMÉRICAS, es decir, no comienzan con letra, solo números.
En este caso convertimos a Integer y los comparamos.

- 2 NINGUNA cadena es NUMÉRICA, es decir, ambas comienzan por letra.
Bien, aquí tendríamos dos "sub escenarios":

- 2A Comienzan por letras DISTINTAS
En este caso, la parte numérica no importa. Solo importan las letras, así que extraemos el primer carácter de cada cadena y los comparamos.

- 2B Comienzan por letras IGUALES
En este caso, hay que extraer de las cadenas las partes numéricas, convertirlas a Integer y compararlas

-3 Tenemos una cadena NUMÉRICA y otra "NO NUMÉRICA"
En este caso, las comparamos como simples String. De esta manera, la NUMÉRICA (la que no comienza por letra) siempre quedará por delante de la otra.


Bien, ya tenemos clara la lógica a seguir, ahora hay que codificarla.

Lo primero que necesitamos, es un modo de saber como distinguir una cadena numérica de otra que no es numérica, o sea, que comienza por letra.
Lo más cómodo es hacer un método boolean y que dentro de un try catch, intente parsear la cadena a Integer.
Si el parseo sale bien, significa que la cadena solo contiene números, así que retornamos TRUE.
Si el parseo falla, será porque la cadena contiene letras. Entonces el catch capturará una excepción, por lo que retornaremos FALSE.

Así que a la clase Repartido, le añadimos este método:
1
2
3
4
5
6
7
8
9
10
11
private boolean esNumerico(String cadena) {
    	try {
    		Integer.parseInt(cadena);
    		//Si el parseo no ha lanzado excepcion, es numérico
    		return true;
    	}
    	catch(Exception ex) {
    		//Si el catch captura excepción, NO es numérico
    		return false;
    	}
    }

Bien, ya tenemos un medio para distinguir entre los dos tipos de cadenas. Podemos ir al compareTo() y codificar los tres posibles escenarios:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Override
    public int compareTo(Repartido otroRep) {
 
    	//Si AMBOS son numéricos, parseamos y comparamos como Integers
    	if (esNumerico(premio) && esNumerico(otroRep.premio)) {
    		Integer esteEntero = Integer.parseInt(premio);
    		Integer otroEntero = Integer.parseInt(otroRep.premio);
    		return esteEntero.compareTo(otroEntero);
    	}
    	//Si NINGUNO es numérico, es decir, comienzan con letra, la comparación es más compleja
    	else if (!esNumerico(premio) && !esNumerico(otroRep.premio))
    		return compararNoNumericos(premio, otroRep.premio);
    	//Si no se cumplen las condiciones anteriores, tenemos uno numérico y otro "no numérico"
    	else
    		//En este caso comparamos como Strings
    		return premio.compareTo(otroRep.premio);
    }

El segundo escenario (ninguna cadena numérica), puesto que tiene dos posibles "sub escenarios", he preferido codificarlo en un método a parte.
De esta forma, el compareTo() queda menos sobrecargado y se entiende mejor la lógica que se está siguiendo.

Este método, hace lo comentado anteriormente.
Si las letras son distintas, se retorna el resultado de compara estas letras.
Si son iguales, se extrae la parte numérica y se comparan como Integer.
Damos por hecho que estas cadenas siempre comienzan con una letra y un guion. De esta manera sabemos que la parte numérica comienza en el carácter #2 de la cadena y hasta el final.
Si las cadenas no cumplen este formato (letra sin guion, dos letras y un guion, letra y dos guiones, espacios en blanco separando el guion de la letra....) entonces el método fallará.
De ahí la importancia de establecer un formato fijo para las cadenas en casos como este.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
private int compararNoNumericos(String cadena1, String cadena2) {
    	/*
    	 * Tenemos dos cadenas que comienzan por letras
    	 * Si las letras son distintas, se retorna la comparación
    	 * de dichas letras, sin importar la parte numérica de la cadena.
    	 *
    	 * Si las letras son iguales, entonces extraemos la parte numérica
    	 * y compararemos como enteros
    	 */
    	if (cadena1.charAt(0) != cadena2.charAt(0)) //Letras distintas
    		return Character.compare(cadena1.charAt(0), cadena2.charAt(0));
    	else { //Letras iguales, compararemos la parte numérica
    		Integer numeros1 = Integer.parseInt(cadena1.substring(2));
    		Integer numeros2 = Integer.parseInt(cadena2.substring(2));
    		return numeros1.compareTo(numeros2);
    	}
    }

Bien, tras añadir estos cambios a la clase Repartido, si probamos de nuevo a ordenar la muestra de premios que puse antes, ahora sí obtenemos el ordenamiento que buscabamos.

1
2
3
4
5
6
7
8
9
2
6
8
22
24
R-1
R-2
R-10
R-22

Incluso si añadimos premios con distintas letras, el orden sigue siendo correcto.
Primero números y luego premios con letra.
Los número ordenados según valor numérico.
Los premios con letra, primero se clasifican por orden de letra, y los que comparten letra, se ordenan según valor numérico:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
2
6
8
22
24
A-4
A-10
C-8
C-18
R-1
R-2
R-10
R-22
X-4
X-6
Z-1
Z-12

Y listo. Si algo no se entiende, solo tienes que preguntarlo.
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
sin imagen de perfil
Val: 53
Ha aumentado su posición en 133 puestos en Java (en relación al último mes)
Gráfica de Java

como puedo ordenar el resultado de esta clase que es un sorteo en java

Publicado por manuel (17 intervenciones) el 08/06/2021 08:17:09
Buenas gracias, una cosa el metodo comparaNoNumerios me faltria, gracias
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: 53
Ha aumentado su posición en 133 puestos en Java (en relación al último mes)
Gráfica de Java

como puedo ordenar el resultado de esta clase que es un sorteo en java

Publicado por manuel (17 intervenciones) el 08/06/2021 08:36:47
Perdona ya lo he visto no me habia fijado. Me da una excepcion cuando hace el Integer en el metodo compararNo Numericos

else { //Letras iguales, compararemos la parte numérica
Integer numeros1 = Integer.parseInt(cadena1.substring(2));

y se pasa a esta linea

return compararNoNumericos(prm, otroRep.prm);

Si quito el else me funciona pero las letras con numeros no me los ordena
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: 53
Ha aumentado su posición en 133 puestos en Java (en relación al último mes)
Gráfica de Java

como puedo ordenar el resultado de esta clase que es un sorteo en java

Publicado por manuel (17 intervenciones) el 08/06/2021 09:04:07
Ya se por que falla por que en vez de poner R-1, he cambiado y he puesto Reserva-1 y por eso me falla
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

como puedo ordenar el resultado de esta clase que es un sorteo en java

Publicado por Kabuto (978 intervenciones) el 08/06/2021 12:40:07
Por eso decía esto:
1
2
Si las cadenas no cumplen este formato entonces el método fallará.
De ahí la importancia de establecer un formato fijo para las cadenas en casos como este.

No hay una fórmula mágica para ordenar cosas de formatos distintos, de una forma muy concreta.

Fíjate que para contemplar dos formatos, muy simples y similares:
"22"
"R-22"

Para ordenarlos como queríamos, ha habido que tener en cuenta 5 posibles situaciones, exigiendo cada una de ellas tratar los datos de distinta forma.

Si se "abre la veda" a que entren datos de cualquier formato:
"22"
"R-22"
"Reserva-22"
"22-R"
"R22"
"Reserva-22-R"
...

Ya no es solo que las posibles situaciones aumenten de forma exponencial, si no que de todos modos es imposible saber cuáles serán esas situaciones, porque se permite recibir cualquier cosa.

Así que antes de ponernos a escribir el código para "comparar cosas", hay que delimitar el formato que tendrán esas cosas, y decidir cómo queremos que se ordenen.
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