Estoy tratando de ordenar un array de Cadenas utilizando compareTo(). Este es mi código:

static String Array[] = {" Hello ", " This ", "is ", "Sorting ", "Example"};
String temp;

public static void main(String[] args)
{

   for (int j=0; j<Array.length;j++)
   {
       for (int i=j+1 ; i<Array.length; i++)
       {
           if (Array[i].compareTo(Array[j])<0)
           {
               String temp = Array[j];
               Array[j] = Array[i];
               Array[i] = temp;
           }
       }
       System.out.print(Array[j]);
   }
}

Ahora el resultado es:

Hello  This Example Sorting is

Estoy consiguiendo resultados, pero no los resultados que se quieren obtener, los cuales son:

Hello This Example Is Sorting

¿Cómo puedo ajustar mi código para ordenar la matriz de cadena correctamente?

  • Usted realmente debe trabajar en su código de convenio.
  • sí yo , infectar a i m nuevo en java . y estaba totalmente atascado con ella , no tenía idea acerca de tales cuestiones de menor importancia ..
  • Un poco de consejo que puedo dar a la hora de programar es consecuente con la convención. Si te equivocas en una cosa, hacer que una cosa mal en todas partes en lugar de hacerlo a la derecha algunos lugares y el mal de otros lugares.
InformationsquelleAutor Sikander | 2012-10-20

8 Comentarios

  1. 146

    Su salida es correcta. Indicar los caracteres en blanco de «Hola» y «Este» en el principio.

    Otro problema es con su metodología. El uso de la Arrays.sort() método:

    String[] strings = { " Hello ", " This ", "Is ", "Sorting ", "Example" };
    Arrays.sort(strings);

    De salida:

     Hello
     This
    Example
    Is
    Sorting

    Aquí el tercer elemento de la matriz «es» debe ser «Es», de lo contrario vendrá en la última después de la ordenación. Debido a que el tipo de método utiliza internamente el valor ASCII para ordenar los elementos.

    • lo que si tengo clase con dos campos: 1) text 2) code. y, a continuación, he creado arraylist. y quiero ordenar arraylist elementos con respecto a text?
    • por favor, lea acerca de la implementación de Comparables interfaz en Java.
  2. 15

    Aparte de las alternativas de solución que fueron publicados aquí (que es correcta), nadie en realidad ha contestado a su pregunta por el tratamiento de lo que estaba mal con su código.

    Parece como si estuviera tratando de implementar un orden de selección algoritmo. No voy a entrar en los detalles de cómo clasificación funciona aquí, pero he incluido un par de enlaces para su referencia =)

    Su código sintácticamente correcta, pero lógicamente incorrecto. Que fueron parcialmente la clasificación de sus cadenas de sólo por la comparación de cada una de las cuerdas con las cadenas que vino después. Aquí es una versión corregida (I retenido como parte de su código original para ilustrar lo que era «malo» con él):

    static  String Array[]={" Hello " , " This " , "is ", "Sorting ", "Example"};
    String  temp;
    
    //Keeps track of the smallest string's index
    int  shortestStringIndex; 
    
    public static void main(String[] args)  
    {              
    
     //I reduced the upper bound from Array.length to (Array.length - 1)
     for(int j=0; j < Array.length - 1;j++)
     {
         shortestStringIndex = j;
    
         for (int i=j+1 ; i<Array.length; i++)
         {
             //We keep track of the index to the smallest string
             if(Array[i].trim().compareTo(Array[shortestStringIndex].trim())<0)
             {
                 shortestStringIndex = i;  
             }
         }
         //We only swap with the smallest string
         if(shortestStringIndex != j)
         {
             String temp = Array[j];
             Array[j] = Array[shortestStringIndex]; 
             Array[shortestStringIndex] = temp;
         }
     }
    }

    Leer Más

    El problema con este enfoque es que su complejidad asintótica es O(n^2). En forma simplificada palabras, se pone muy lento como el tamaño de la matriz crece (enfoque infinito). Usted puede leer acerca de mejores maneras de ordenar los datos, tales como quicksort.

  3. 9

    Lugar de esta línea

    if(Array[i].compareTo(Array[j])<0)

    el uso de esta línea

    if(Array[i].trim().compareTo(Array[j].trim())<0)

    y que son buenos para ir. La razón de su código actual no está funcionando es explicado por otros usuarios ya. Esta por encima de reemplazo es una solución entre varias que se podría aplicar.

  4. 9

    Sé que esto es una respuesta tardía, pero tal vez pueda ayudar a alguien.

    La eliminación de espacio en blanco se puede hacer mediante el uso de la función trim ().
    Después de eso, si usted desea ordenar el array con mayúsculas de minúsculas manera que usted puede usar:

    Arrays.sort(yourArray);

    y para no distingue mayúsculas de minúsculas manera:

    Arrays.sort(yourArray,String.CASE_INSENSITIVE_ORDER);

    Espero que esto ayude!

  5. 5

    A partir de Java 8, también puede utilizar parallelSort que es útil si usted tiene los arrays que contienen una gran cantidad de elementos.

    Ejemplo:

    public static void main(String[] args) {
        String[] strings = { "x", "a", "c", "b", "y" };
        Arrays.parallelSort(strings);
        System.out.println(Arrays.toString(strings));   //[a, b, c, x, y]
    }

    Si quieres ignorar el caso, se puede utilizar:

    public static void main(String[] args) {
        String[] strings = { "x", "a", "c", "B", "y" };
        Arrays.parallelSort(strings, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {              
                return o1.compareToIgnoreCase(o2);
            }
        });
        System.out.println(Arrays.toString(strings));   //[a, B, c, x, y]
    }

    lo contrario B será antes de a.

    Si quieres ignorar los espacios durante la comparación, puede utilizar trim():

    public static void main(String[] args) {
        String[] strings = { "x", "  a", "c ", " b", "y" };
        Arrays.parallelSort(strings, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {              
                return o1.trim().compareTo(o2.trim());
            }
        });
        System.out.println(Arrays.toString(strings)); //[  a,  b, c , x, y]
    }

    Ver:

  6. 4

    " Hello " , " This " , "is ", "Sorting ", "Example"

    Primero de todo es que siempre espacios en " Hello " y " This ", los espacios tienen un valor inferior al de los caracteres alfabéticos en Unicode, por lo que se imprime en primer lugar. (El resto de los caracteres se ordenan alfabéticamente).

    Ahora en letras mayúsculas tienen un valor inferior al de la letra minúscula en Unicode, por lo que «el Ejemplo» y «Ordenar» que se imprime, a continuación, en última "is " que tiene el valor más alto.

  7. 4

    Si usted utiliza:

    if (Array[i].compareToIgnoreCase(Array[j]) < 0)

    se obtiene:

    Example  Hello  is  Sorting  This

    que creo que es la salida que usted estaba buscando.

    • que creo que es la salida que estaban buscando para – No de acuerdo a la edición que pasó ayer.
  8. 3

    Para empezar, el problema es que se utiliza el método compareTo (), el cual es sensible a mayúsculas y minúsculas. Eso significa que el Capital de las letras se ordenan aparte de la carcasa inferior. La razón es que se traduce en Unicode donde las letras mayúsculas se presentan con números que son menores que los presentados número de minúsculas. Por lo tanto se debe utilizar `compareToIgnoreCase()` como muchos también mencionado en posts anteriores.

    Este es mi ejemplo completo enfoque de cómo se puede hacer effecively

    Después de crear un objeto de la Comparador puede pasar en esta versión de `sort ()`, que se define en java.util.Matrices.

    static<T>void sort(T[]array,Comparator<?super T>comp)

    tomar un vistazo de cerca a super. Esto hace que la matriz que pasa es combatible con el tipo de comparador.

    La parte mágica de esta manera es que usted puede fácilmente ordenar el array de cadenas de caracteres en orden Inverso usted puede hacer fácilmente por:

    return strB.compareToIgnoreCase(strA);

    import java.util.Comparator;
    
        public class IgnoreCaseComp implements Comparator<String> {
    
            @Override
            public int compare(String strA, String strB) {
                return strA.compareToIgnoreCase(strB);
            }
    
        }

      import java.util.Arrays;
    
        public class IgnoreCaseSort {
    
            public static void main(String[] args) {
                String strs[] = {" Hello ", " This ", "is ", "Sorting ", "Example"};
                System.out.print("Initial order: ");
    
                for (String s : strs) {
                    System.out.print(s + " ");
                }
    
                System.out.println("\n");
    
                IgnoreCaseComp icc = new IgnoreCaseComp();
    
                Arrays.sort(strs, icc);
    
                System.out.print("Case-insesitive sorted order:  ");
                for (String s : strs) {
                    System.out.print(s + " ");
                }
    
                System.out.println("\n");
    
                Arrays.sort(strs);
    
                System.out.print("Default, case-sensitive sorted order: ");
                for (String s : strs) {
                    System.out.print(s + " ");
                }
    
                System.out.println("\n");
            }
    
        }

     run:
        Initial order:  Hello   This  is  Sorting  Example 
    
        Case-insesitive sorted order:   Hello   This  Example is  Sorting  
    
        Default, case-sensitive sorted order:  Hello   This  Example Sorting  is  
    
        BUILD SUCCESSFUL (total time: 0 seconds)

    Alternativa

    El método compareToIgnoreCase(), aunque funciona bien con muchas ocasiones(como comparar la cadena en inglés),que no funcionan bien con todos los idiomas y ubicaciones. Esto automáticamente hace que sea un inepto elección para su uso. Para asegurarse de que va a ser suppoorted en todas partes debe utilizar compare() de java.texto.Alzadora.

    Usted puede encontrar un clasificador para su ubicación en la llamada al método getInstance(). Después de que usted debe establecer esta La fuerza de la propiedad. Esto se puede hacer con el setStrength() método junto con Collator.PRIMARY como parámetro. Con esta alternativa será la IgnocaseComp pueden ser escritos tal y como a continuación. Esta versión de código generará el mismo resultado independientemente de la ubicación

    import java.text.Collator;
    import java.util.Comparator;
    
    //this comparator uses one Collator to determine 
    //the right sort usage with no sensitive type 
    //of the 2 given strings
    public class IgnoreCaseComp implements Comparator<String> {
    
        Collator col;
    
        IgnoreCaseComp() {
            //default locale
            col = Collator.getInstance();
    
            //this will consider only PRIMARY difference ("a" vs "b")
            col.setStrength(Collator.PRIMARY);
        }
    
        @Override
        public int compare(String strA, String strB) {
            return col.compare(strA, strB);
        }
    
    }

Dejar respuesta

Please enter your comment!
Please enter your name here