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

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

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);

    }

}

private ArrayList<Repartido> asignacion

asignacion.sort(null);

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);

    }

@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;

	}

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

@Override

    public int compareTo(Repartido otroRep) {

        return prm.compareTo(otroRep.getPrm());

    }

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);

	}

}

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();

			}

		});

	}

}

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);

	}

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);

	}

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.

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

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

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

"letra guión número" --> G-45

"letra número" --> G45

"solo número" --> 45

G-45

B-50

G-410

B-45

G-410

G-45

B-45

G-45

G-410

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

1,R-1,2,R-2

1,2,R-1,R-2

R-1,R-2,1,2

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());

	}

}

2

22

24

6

8

R-1

R-10

R-2

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;

    	}

    }

@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);

    }

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);

    	}

    }

2

6

8

22

24

R-1

R-2

R-10

R-22

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

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.