Ordenar array

[vinucho]

Pessoal,

O código abaixo eu carrego no rankList, uma lista de todos os jogadores que existe no banco, mas eu precisava ordenar essa lista de acordo com o valor do scanPlayer.getRank().

Alguém pode me ajudar?

for (int i=0; i<n && !found; i++) {
Player scanPlayer = players.getPlayer()[i];
rankList[i] = scanPlayer.getPersonalInfo().getNickName() + ": " + scanPlayer.getRank();
}
rank = new List (“Classificação”, List.IMPLICIT, rankList, null);
rank.addCommand(backCommand);
rank.setCommandListener(this);

Obrigado.

[fcoury]

vinucho,

Tenta isso:

		Arrays.sort(array, new Comparator() {
			public int compare(Object o1, Object o2) {
				if (o1 instanceof Player && o2 instanceof Player) {
					if (((Player) o1).getRank() > ((Player) o2).getRank()) {
						return 1;
					}
					else if (((Player) o1).getRank() < ((Player) o2).getRank()) {
						return -1;
					}
					else {
						return 0;
					}
				}
				return 0;
			}
		});

Abraços!

Felipe.

[fcoury]

vinucho,

Fiz um exemplo mais interessante que utiliza features do Java 5:

package com.br.testing;

import java.util.Arrays;
import java.util.Comparator;
import java.util.Random;

public class Player {
	private int rank;
	
	public Player(int rank) {
		this.rank = rank;
	}
	
	public static void main(String[] args) {
		Player[] players = createPlayers(10);
		sortPlayersByRank(players);
		for (Player player : players) {
			System.out.println(player.getRank());
		}
	}
	
	public static Player[] createPlayers(int size) {
		Player[] players = new Player[size]; 
			
		Random r = new Random();
		for (int i = 0; i < size; i++) {
			players[i] = new Player(r.nextInt(100));
		}
		
		return players; 
	}
	
	public static void sortPlayersByRank(Player[] players) {
		Arrays.sort(players, new Comparator<Player>() {

			public int compare(Player p1, Player p2) {
				if (p1.getRank() > p2.getRank()) {
					return 1;
				}
				else if (p1.getRank() < p2.getRank()) {
					return -1;
				}
				return 0;
			}
			
		});
	}

	public int getRank() {
		return rank;
	}

	public void setRank(int rank) {
		this.rank = rank;
	}
}

Cheers!

Felipe.

[Realm]

Muito bom Felipe, mas vc esqueceu que este fórum eh de J2ME, ou seja,
não tem Comparator, Arrays…

Vinucho, aqui vai uma das técnicas que eu uso, eh uma das mais rápidas para
serem utilizadas no J2ME, eh o Shell Sort, é só adaptar para o que vc quer usar:

public class SortUtil {
	
	public static void shellSort(int numbers[]) {
		int i, j, increment, temp;

		increment = 3;
		while (increment &gt 0) {
			for (i = 0; i &lt numbers.length; i++) {
				j = i;
				temp = numbers[i];
				while ((j &gt= increment) && (numbers[j - increment] &gt temp)) {
					numbers[j] = numbers[j - increment];
					j = j - increment;
				}
				numbers[j] = temp;
			}
			if (increment / 2 != 0)
				increment = increment / 2;
			else if (increment == 1)
				increment = 0;
			else
				increment = 1;
		}
	}
	
	public static void shellSort(String numbers[], boolean invert) {
		int i, j, increment;
		String temp;

		increment = 3;
		while (increment &gt 0) {
			for (i = 0; i &lt numbers.length; i++) {
				j = i;
				temp = numbers[i];
				while ((j &gt= increment) && 
						( 
						  ((!invert) && (numbers[j - increment].compareTo(temp) &gt 0)) ||
						  ((invert) && (numbers[j - increment].compareTo(temp) &lt 0))
						)
					  ) {
					numbers[j] = numbers[j - increment];
					j = j - increment;
				}
				numbers[j] = temp;
			}
			if (increment / 2 != 0)
				increment = increment / 2;
			else if (increment == 1)
				increment = 0;
			else
				increment = 1;
		}
	}
	
	public static void shellSort(String values[][], int column, boolean invert) {
		int i, j, increment;
		String temp[];

		increment = 3;
		while (increment &gt 0) {
			for (i = 0; i &lt values.length; i++) {
				j = i;
				temp = values[i];
				while ((j &gt= increment) && 
						( 
						  ((!invert) && (values[j - increment][column].compareTo(temp[column]) &gt 0)) ||
						  ((invert) && (values[j - increment][column].compareTo(temp[column]) &lt 0))
						)
					  ) {
					values[j] = values[j - increment];
					j = j - increment;
				}
				values[j] = temp;
			}
			if (increment / 2 != 0)
				increment = increment / 2;
			else if (increment == 1)
				increment = 0;
			else
				increment = 1;
		}
	}

	public static void main(String args[]) {
		
		SortUtil sortUtil = new SortUtil();
		
		int[] array = new int[] {3, 4, 2, 5, 1, 0};
		
		sortUtil.shellSort(array);
		
		for (int i = 0; i &lt array.length; i++) {
			System.out.println(array[i]);
		}
		
		System.out.println("-------------");
		
		String[] ses = new String[] {"C", "D", "A", "B", "F", "E"};
		
		sortUtil.shellSort(ses, false);
		
		for (int i = 0; i &lt ses.length; i++) {
			System.out.println(ses[i]);
		}

		System.out.println("-------------");
		sortUtil.shellSort(ses, true);
		
		for (int i = 0; i &lt ses.length; i++) {
			System.out.println(ses[i]);
		}
		
		System.out.println("Teste do array bi-dimensional");
		String[][] bis = new String[][] {
				{"1", "C"},
				{"2", "A"},
				{"3", "D"},
				{"4", "B"},
		};
		sortUtil.shellSort(bis, 1, false);
		
		for (int i = 0; i &lt bis.length; i++) {
			System.out.println(bis[i][0] + " - " + bis[i][1]);
		}
		System.out.println("Teste do array bi-dimensional invertido");
		sortUtil.shellSort(bis, 1, true);
		
		for (int i = 0; i &lt bis.length; i++) {
			System.out.println(bis[i][0] + " - " + bis[i][1]);
		}
		
	}
}

[fcoury]

Literalmente, VIAJEI…

Desculpem