Arquivo Discussoes de Programacao e Tecnologia Pessoal, tenho uma dúvida: Na minha tabela tenho 3 linhas com os valores:
1
2
10
Esses valores são STRING. Por isso, quando mando ordenar o resultado é:
1
10
2
Alguém sabe se há como ordenar String sem converter isso pra inteiro de forma que o resultado seja da forma inteiro?
1
2
10
consulte a tabela ASCII
vc pode ordenar pela classificação decimal de cada caracter…
vai dar trabalho, mas é possivel!
por curiosidade…
pq nao pode converter?
Eu fiz isto faz algum tempo, veja se isto lhe interessa.
import java.util.*;
/**
* Este Comparator destina-se a ordenar arrays Object[][] que são usados em JTables.
*
*/
class ComparadorJTable implements Comparator {
private boolean crescente = true;
private int coluna = 0;
private boolean numerico = false;
private boolean ignoraMaiusculas = true;
/**
* Use este construtor para definir um Comparator customizado.
* @param pCrescente Se a comparação deve ficar em ordem crescente ou decrescente.
* @param pColuna O número da coluna do Object[][] que vai ser usado como referência para ordenação.
* A primeira coluna é 0.
* @param pNumerico Se a comparação considera que os valores dessa coluna são numéricos.
* @param pIgnoraMaiusculas Se a comparação ignora maiúsculas.
*/
public ComparadorJTable (boolean pCrescente, int pColuna, boolean pNumerico, boolean pIgnoraMaiusculas) {
crescente = pCrescente;
coluna = pColuna;
numerico = pNumerico;
ignoraMaiusculas = pIgnoraMaiusculas;
}
/**
* @see java.util.Comparator
*/
public int compare (Object obj1, Object obj2) {
if (obj1 instanceof Object[] && obj2 instanceof Object[]) {
// Os objetos são comparáveis
int ret = 0;
int col = coluna;
int maxcol = ((Object[])obj1).length;
do {
ret = compareColuna ((Object[])obj1, (Object[])obj2, col);
col++;
} while (ret == 0 && col < maxcol);
return ret;
} else {
throw new ClassCastException("Use um Object [][]. O tipo de obj1 = "
+ (obj1 != null ? obj1.getClass().getName() : "null")
+ ", e o tipo de obj2 = "
+ (obj2 != null ? obj2.getClass().getName() : "null"));
}
}
/**
*/
private int compareColuna (Object[] obj1, Object[] obj2, int col) {
int ret;
String val1 = obj1[col].toString();
String val2 = obj2[col].toString();
if (numerico) {
double d1 = Double.NEGATIVE_INFINITY;
double d2 = Double.NEGATIVE_INFINITY;
try {
d1 = Double.parseDouble (val1.trim());
} catch (NumberFormatException ex) {
}
try {
d2 = Double.parseDouble (val2.trim());
} catch (NumberFormatException ex) {
}
ret = (d1 < d2) ? -1 : ((d1 > d2) ? +1 : 0);
} else if (ignoraMaiusculas) {
ret = val1.compareToIgnoreCase (val2);
} else {
ret = val1.compareTo (val2);
}
if (!crescente)
ret = -ret;
return ret;
}
}
class OrdenacaoNumerica {
private static void print(String msg, Object obj[][]) {
System.out.println ("-----");
System.out.println (msg);
System.out.println ("-----");
for (int i = 0; i < obj.length; ++i) {
Object[] row = obj[i];
for (int j = 0; j < row.length; ++j) {
System.out.print ("[" + obj[i][j] + "] ");
}
System.out.println ();
}
}
public static void main(String[] args) {
Object obj [][] = {
{ "100", "123", "345" },
{ "20", "abc", "123" },
{ "3", " tres palitos ", "22"},
{ "3", " tres palitos ", "12"},
{ "789", " anfoteros", "2345"},
};
print ("Original", obj);
Arrays.sort (obj, new ComparadorJTable (true, 0, true, true));
print ("Ordem crescente, primeira coluna", obj);
Arrays.sort (obj, new ComparadorJTable (false, 1, true, true));
print ("Ordem decrescente, segunda coluna", obj);
Arrays.sort (obj, new ComparadorJTable (true, 2, true, true));
print ("Ordem crescente, última coluna", obj);
}
}
Ficou meio tosco mas não tem conversão de String para int:
public class teste{
public teste(){
List<String> lista = new ArrayList<String>();
lista.add("1");
lista.add("10");
lista.add("2");
lista.add("20");
lista.add("19");
lista.add("3");
lista.add("300");
Collections.sort(lista, new Comparar());
for(String aux : lista){
System.out.println(aux);
}
}
public static void main(String args[]) {
new teste();
}
class Comparar implements Comparator<String>{
public int compare(String a, String b) {
if(a.length() == b.length()) return a.compareTo(b);
else if(a.length() > b.length()) return 1;
else return 0;
}
}
}
Em um momento de tédio eu fiz um benchmark entre convertento e não convertento, sem converter ficou bem mais rápido, só tem um problema não está funcionando com negativos, tem que fazer mais uns testes no comparator:
public class teste{
public List<String> teste1(List<String> list){
Collections.sort(list, new Comparar());
return list;
}
public List<String> teste2(List<String> list){
Collections.sort(list, new Comparar2());
return list;
}
public static void main(String args[]) {
ArrayList<String> lista = new ArrayList<String>();
ArrayList<String> lista2;
Random random = new Random();
for(int i=0; i<555555; i++){
lista.add(random.nextInt(10000000)+"");
}
lista2 = (ArrayList<String>)lista.clone();
Long l1 = System.currentTimeMillis();
new teste().teste1(lista);
System.out.println("Teste sem conversão: " + (System.currentTimeMillis() - l1) + '\n');
l1 = System.currentTimeMillis();
new teste().teste2(lista2);
System.out.println("Teste com conversão: " + (System.currentTimeMillis() - l1));
}
class Comparar implements Comparator<String>{
public int compare(String a, String b) {
if(a.length() == b.length()) return a.compareTo(b);
else if(a.length() > b.length()) return 1;
else return 0;
}
}
class Comparar2 implements Comparator<String>{
public int compare(String a, String b){
Integer primeiro = Integer.valueOf(a);
Integer segundo = Integer.valueOf(b);
return primeiro.compareTo(segundo);
}
}
}