Bom dia tenho uma duvída. Eu tenho que fazer uma pesquisa de Strings, ela vem ordenada por padrão assim Alpha 100, Alpha 2, Alpha 200, Alpha 2A, Alpha 2A-8000, Alpha 2A-900
e eu gostaria de ordenar assim Alpha 2, Alpha 2A, Alpha 2A-900, Alpha 2A-8000, Alpha 100, Alpha 200 mas eu não sei como fazer se alguém poder me ajudar. Agradeço.
Tentei dessa forma mas meu resultado foi : Alpha 100, Alpha 2A-8000, Alpha 2A-900, Alpha 200, Alpha 2, Alpha 2A.
Também gostaria de saber como solucionar esse problema.
Acho que deve ser por esse caminho.
public static void main(String args[]) {
String [] strings = {"Alpha 100", "Alpha 2", "Alpha 200", "Alpha 2A", "Alpha 2A-8000", "Alpha 2A-900" };
Collections.sort(Arrays.asList(strings), new Comparator<String>(){
@Override
public int compare(String s1, String s2) {
if(s1.compareTo(s2) == -1)
return -1;
else if(s1.compareTo(s2) == 0)
return 0;
return 1;
}
});
for (String s : strings) {
System.out.print(s +", ");
}
}CyberX.
[quote=CyberX]Tentei dessa forma mas meu resultado foi : Alpha 100, Alpha 2A-8000, Alpha 2A-900, Alpha 200, Alpha 2, Alpha 2A.
Também gostaria de saber como solucionar esse problema.
Acho que deve ser por esse caminho.
public static void main(String args[]) {
String [] strings = {"Alpha 100", "Alpha 2", "Alpha 200", "Alpha 2A", "Alpha 2A-8000", "Alpha 2A-900" };
Collections.sort(Arrays.asList(strings), new Comparator<String>(){
@Override
public int compare(String s1, String s2) {
if(s1.compareTo(s2) == -1)
return -1;
else if(s1.compareTo(s2) == 0)
return 0;
return 1;
}
});
for (String s : strings) {
System.out.print(s +", ");
}
}CyberX.[/quote]
Campeão, não é mais fácil isso ?
String [] strings = {"Alpha 100", "Alpha 2", "Alpha 200", "Alpha 2A", "Alpha 2A-8000", "Alpha 2A-900" };
Collections.sort(Arrays.asList(strings), new Comparator<String>(){
@Override
public int compare(String s1, String s2) {
return s1.compareTo(s2);
}
});Você fez algo assim: “se s1.compareTo(s2) for igual a -1, retorna menos -1”. Portanto, retornar diretamente o resultado é mais eficiente.
Infelizmente não posso testar os resultados agora, todavia, é implementar o comparator e buscar a solução adequada a sua necessidade.
Fiz dessa forma e a saída foi a mesma que o robson18 informou.
Então por esse motivo fiz dessa outra forma.
Achei estranho mas não sei o porque isso aconteceu.
Voltando… Qual seria a melhor forma então para essa saída: Alpha 2, Alpha 2A, Alpha 2A-900, Alpha 2A-8000, Alpha 100, Alpha 200
Estou curioso para essa solução.
[code]public static void main(String[] args) {
String[] strings = { "Alpha 100", "Alpha 2", "Alpha 200", "Alpha 2A",
"Alpha 2A-8000", "Alpha 2A-900" };
Collections.sort(Arrays.asList(strings), new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return(s1.compareTo(s2));
}
});
for (String s : strings) {
System.out.print(s + ", ");
}
}[/code]
acho que isso resolve :thumbup:
espero ter ajudado!
Read the First Post ^
Comparando dessa forma a saída é: Alpha 100, Alpha 2, Alpha 200, Alpha 2A, Alpha 2A-8000, Alpha 2A-900
que não é a saída que o Robson quer, mas a saída que ele quer é:
Alpha 2, Alpha 2A, Alpha 2A-900, Alpha 2A-8000, Alpha 100, Alpha 200
[quote=CyberX]Read the First Post ^
Comparando dessa forma a saída é: Alpha 100, Alpha 2, Alpha 200, Alpha 2A, Alpha 2A-8000, Alpha 2A-900
que não é a saída que o Robson quer, mas a saída que ele quer é:
Alpha 2, Alpha 2A, Alpha 2A-900, Alpha 2A-8000, Alpha 100, Alpha 200[/quote]
Porque o comparator da String fez “correto”. Acontece, que o ele precisa é um outro modelo, portanto, cabe a ele decidir de que forma implementar isso ou sugestões.
Essa saída eu consegui antes e pedir ajuda Alpha 100, Alpha 2, Alpha 200, Alpha 2A, Alpha 2A-8000, Alpha 2A-900, mas
a saída certa eu não estou conseguindo. O meu professor deu essa dica. Quebre cada linha de entrada em um grupo de letras e um grupo de inteiros, e compare cada
grupo, linha a linha. Você pode dividir seu problema em problemas menores
[quote=nel][quote=CyberX]Read the First Post ^
Comparando dessa forma a saída é: Alpha 100, Alpha 2, Alpha 200, Alpha 2A, Alpha 2A-8000, Alpha 2A-900
que não é a saída que o Robson quer, mas a saída que ele quer é:
Alpha 2, Alpha 2A, Alpha 2A-900, Alpha 2A-8000, Alpha 100, Alpha 200[/quote]
Porque o comparator da String fez “correto”. Acontece, que o ele precisa é um outro modelo, portanto, cabe a ele decidir de que forma implementar isso ou sugestões.[/quote]
Ok !? Agora vem as perguntas… De que modelo ele precisa ? Como implementar ou que sugestão deve ser informada ?
Tem algum exemplo plausível para que possamos solucionar essa questão ?
Waiting…
[quote=robson18]Essa saída eu consegui antes e pedir ajuda Alpha 100, Alpha 2, Alpha 200, Alpha 2A, Alpha 2A-8000, Alpha 2A-900, mas
a saída certa eu não estou conseguindo. O meu professor deu essa dica. Quebre cada linha de entrada em um grupo de letras e um grupo de inteiros, e compare cada
grupo, linha a linha. Você pode dividir seu problema em problemas menores[/quote]
Legal essa pode ser uma saída para o problema !
Encoding…
Qual a regra da ordenação? O que é define que um caractere ou palavra é “maior”/“menor” ou vem antes ou depois que a outra?
Cara eu fiz algo aqui… mas só só vai funciona se vc seguir o padrão:
<espaço> <ifém>
o resto eu não garanto!
[code]import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
public class MyComparator implements Comparator {
@Override
public int compare(String arg0, String arg1) {
if(arg0.contains("-") && arg1.contains("-")){
String a[] = arg0.split("-");
String b[] = arg1.split("-");
if(a[0].equals(b[0])){
int numA = Integer.parseInt(a[1]);
int numB = Integer.parseInt(b[1]);
if(numA < numB){
return -1;
}
else if(numA == numB){
return 0;
}
else{
return 1;
}
}
}
if(arg0.contains(" ") && arg0.contains(" ")){
String a[] = arg0.split(" ");
String b[] = arg1.split(" ");
if(a[0].equals(b[0])){
try{
int numA = Integer.parseInt(a[1]);
int numB = Integer.parseInt(b[1]);
if(numA < numB){
return -1;
}
else if(numA == numB){
return 0;
}
else{
return 1;
}
}
catch (Exception e) {
if(arg0.contains("-") && arg0.contains("-")){
return compare(arg0, arg1);
}
else {
int comp = complexComparator(a[1], b[1]);
if(0 == comp){
return a[1].compareTo(b[1]);
}
return comp;
}
}
}
}
return arg0.compareTo(arg1);
}
private int complexComparator(String arg0, String arg1){
char a[] = arg0.toCharArray();
char b[] = arg1.toCharArray();
String temp = "";
int numA = 0;
int numB = 0;
for (char c : a) {
try{
Integer.parseInt(c+"");
temp += c;
}catch (Exception e) {
if(temp.length() > 0){
numA = Integer.parseInt(temp);
//System.out.println("Temp maior que 0 em A");
}
break;
}
finally{
if(temp.length() > 0){
numA = Integer.parseInt(temp);
}
}
}
temp = "";
for (char c : b) {
try{
Integer.parseInt(c+"");
temp += c;
}catch (Exception e) {
if(temp.length() > 0){
numB = Integer.parseInt(temp);
//System.out.println("Temp maior que 0 em B");
}
break;
}
finally{
if(temp.length() > 0){
numB = Integer.parseInt(temp);
}
}
}
//System.out.println("Complexo: " + arg0 + ": " + numA + " - " + arg1 + ": " + numB);
return numA - numB;
}
public static void main(String[] args) {
String [] strings = {"Alpha 100", "Alpha 2", "Alpha 200", "Alpha 2A", "Alpha 2A-8000", "Alpha 2A-900" };
Collections.sort(Arrays.asList(strings), new MyComparator());
for (String string : strings) {
System.out.println(string);
}
}
}
[/code]
É isso que estamos tentando descobrir.
Encoding…
[quote=Rafael_Leal]Cara eu fiz algo aqui… mas só só vai funciona se vc seguir o padrão:
<espaço> <ifém>
o resto eu não garanto!
[/quote]
LOK muito bom esse algoritmo, claro que seguindo essa linha de raciocínio lógico ’ <espaço> <ifém> ’
Vou dar uma estudada nessa algoritmo entender e usar para outras funções.
Congratulations [i]Rafael_Leal[/i]. Thanks for the help.
Cara era isso mesmo, os parametros da pesquisa eram só esses. Valew…
Altere o status do seu post para [Resolvido] para ficar claro que sua dúvida foi sanada!
Tks.
Tinha um erro na linha 18… a segunda comparação do if tava errada! CORRIGI!!!