ordenar por java usando la clase anónima

Question

Tengo clase en la que estoy ordenando una lista.

import java.util.*; 

public class First 
{ 

    private static HashMap<String,Second> msgs; 

    public static void main(String[] args) 
    {   

    List<String> ls=new ArrayList<String>(); 


    ls.add("fourth"); 
    ls.add("2"); 
    ls.add("second"); 
    ls.add("first"); 
    ls.add("third"); 
    ls.add("1"); 

    Iterator it=ls.iterator(); 

    // before sorting 
    while(it.hasNext()) 
    { 
    String s=(String)it.next(); 
    System.out.println(s); 
    } 

    Collections.sort(ls, new Comparator(){ 
     public int compare(Object o1, Object o2) { 
      return -1; 
      // it can also return 0, and 1 
     } 
    }); 

System.out.println(" "); 

//after sorting 
    Iterator iti=ls.iterator(); 
    while(iti.hasNext()) 
    { 
    String s=(String)iti.next(); 

    System.out.println(s); 
    } 

} 


} 

Después se ejecuta el programa, consigo estos valores:

1  
third 
first 
second 
2 
fourth 

Mi pregunta es ¿cuál es el comportamiento de Collection.sort() la función aquí. Al devolver -1 desde la función de comparación, obtenemos el orden inverso de la lista. Entonces, ¿cómo podemos obtener otras órdenes de clasificación? ¿Cuál es el rol de devolver 0 y 1?

Answer 1

Finalmente, modifiqué la función de clasificación de esta manera para obtener datos ordenados.

Collections.sort(ls, new Comparator() 
          { 

          public int compare(Object o1, Object o2) 
          { 
          String sa = (String)o1; 
          String sb = (String)o2; 

          int v = sa.compareTo(sb); 

          return v;   

           // it can also return 0, and 1 
          } 
          }  
        ); 

Answer 2

Esto es lo the javadoc dice:

int comparar (T o1, o2 T)

compara sus dos argumentos para la orden. Devuelve un entero negativo, cero o entero positivo ya que el primer argumento es menor que, igual a , o mayor que el segundo.

La implementación de su comparador no respeta este contrato, por lo que el resultado es indeterminado. Debe devolver un valor negativo si considera que o1 es menor que o2. Debe devolver un valor positivo si considera que o1 es mayor que o2. Y debe devolver 0 si considera que o1 es igual a o2. Y debe ser consecuente, por supuesto. Si o1 < o2, entonces o2> o1. Si o1 < o2 y o2 < o3, entonces o1 < o3.

Answer 3

¿Cuál es el rol de devolver 0 y 1?

Es decir que el o1 o2 es igual a, o o1 es mayor que o2.

Tu comparador anónima actualmente dice que o1 o2 es inferior, para cada valor posible de o1 y o2. Esto simplemente no tiene sentido y hace que el comportamiento de sort sea impredecible.

A válido comparador debe implementar el método compare(Object, Object) de manera que se comporta de acuerdo con los requisitos de la interfaz de Comparator.

---

Si su verdadero objetivo es invertir el orden de los elementos de una lista, a continuación, no utilice sort. Utilice Collections.reverse()

Answer 4

de Javadoc del Comparador

Compares its two arguments for order. Returns a negative integer, 
zero, or a positive integer as the first argument is less than, equal 
to, or greater than the second. 

Así definen la funcionalidad del menor, igual o mayor que para su clase, se echa en falta igual y superior a la funcionalidad.

Answer 5

java.util.Comparator clase dice en compare método doc java:

un entero negativo, cero o un número entero positivo como el primer argumento es menor que, igual a, o mayor que el segundo .

puede utilizar el código siguiente:

Collections.sort(ls, new Comparator() 
{ 
    public int compare(Object o1, Object o2) 
    { 
     if(o1 instanceof String && o2 instanceof String) 
     { 
      String s_1 = (String)o1; 
      String s_2 = (String)o2; 

      return s_1.compareTo(s_2); 
     } 
     return 0;  
    } 
}); 

Este código debe trabajar fine.You puede cambiar comparar método para una mayor flexibilidad.

compareTo método en la clase String dice en su java doc:

el valor 0 si el argumento cadena es igual a esta cadena; un valor menor que 0 si esta cadena es lexicográficamente menor que el argumento de cadena; y un valor de mayor que 0 si esta cadena es lexicográficamente mayor que el argumento de cadena.

Answer 6

Puede utilizar clase anónima de esta manera:

TreeSet<String> treeSetObj = new TreeSet<String>(new Comparator<String>() { 
    public int compare(String i1,String i2) 
    { 
     return i2.compareTo(i1); 
    } 
});