Ordenar un array de cadenas alfabéticamente en Java

Mohammad Irfan 12 octubre 2023

Java Java String Java Array

Ordene un array de cadenas sin utilizar métodos integrados en Java
Ordene un array de cadenas utilizando el método stringArraySort() en Java
Ordene un array de cadenas utilizando el método compareTo() en Java
Ordene un array de cadenas utilizando el método Arrays.sort() en Java
Ordenar un array de cadenas en orden descendente en Java
Ordene un array de cadenas ignorando el caso en Java
Ordenar un array de cadenas alfabéticamente en Java

Ordenar un array de cadenas alfabéticamente en Java

Este tutorial presenta cómo ordenar matrices de cadenas alfabéticamente en Java. También hemos enumerado algunos códigos de ejemplo para ayudarlo a comprender el tema.

Ordenar consiste en organizar los datos en un orden particular. Podemos ordenar números enteros en orden ascendente o descendente, o podemos ordenar caracteres o palabras en inglés en orden lexicográfico.

El orden lexicográfico es el orden en el que aparecerían las palabras si estuvieran presentes en un diccionario de palabras en inglés. En esta guía, le enseñaremos cómo ordenar un array de cadenas en Java.

Compararemos cadenas en este artículo con palabras como menor o mayor. Una cadena es más pequeña que la otra si aparece primero según el orden lexicográfico.

Además, en el orden lexicográfico, todas las letras mayúsculas preceden a las minúsculas; esto significa que una palabra que comienza con Z estará presente antes de una palabra que comience con a en un array ordenada.

Ordene un array de cadenas sin utilizar métodos integrados en Java

Primero intentaremos implementar nuestro propio método de clasificación en Java. Crearemos un método llamado compareStrings(), que compara dos cadenas y nos dice cuál es más pequeña o más grande.

A continuación, compararemos cada cadena con todas las demás cadenas presentes en el array utilizando nuestro método compareStrings() y colocaremos esa cadena en su posición correcta. El algoritmo para los dos métodos se da a continuación.

La entrada para este método serán dos cadenas y devolverá un valor entero. El resultado de este método es el siguiente.
- Si cadena1> cadena2: devuelve un entero positivo
- Si cadena1 <cadena2: devuelve un entero negativo
- Si cadena1 == cadena2: devuelve 0
Recorreremos cada carácter de ambas cadenas simultáneamente y compararemos sus valores Unicode. Usamos el método incorporado charAt() para obtener los valores Unicode. Estos valores nos permiten comparar caracteres como si fueran enteros normales.
Si los valores Unicode son los mismos para ambos caracteres, pasaremos al siguiente carácter de cada cadena.
Si los valores Unicode difieren, devolvemos la diferencia de los valores.
el bucle termina cuando nos quedamos sin caracteres de cualquiera de las cadenas.
Si las dos cadenas tienen diferentes longitudes fuera del bucle, devolvemos esta diferencia. Hacemos esto porque todos los caracteres de la cadena más pequeña pueden estar presentes al comienzo de la más larga. Por ejemplo, aplicación y aplicación. En este caso, la cuerda más larga vendrá después de la más pequeña.
Si las cadenas tienen la misma longitud, simplemente devolveremos 0, lo que indica que las dos cadenas son iguales.

Ordene un array de cadenas utilizando el método `stringArraySort()` en Java

Este método tomará un array de cadenas como entrada y devolverá el array ordenada. Aquí, tendremos dos bucles, uno anidado en el otro. Se utilizan para comparar cada elemento del array con todos los elementos restantes.

Los comparamos usando nuestro método compareString() para cada par de elementos dentro del bucle. Si la primera cadena es mayor en comparación con la otra, intercambiamos sus posiciones.

El código completo se muestra a continuación.

public class Main {
  public static int compareStrings(String word1, String word2) {
    for (int i = 0; i < Math.min(word1.length(), word2.length()); i++) {
      if ((int) word1.charAt(i) != (int) word2.charAt(i)) // comparing unicode values
        return (int) word1.charAt(i) - (int) word2.charAt(i);
    }
    if (word1.length()
        != word2.length()) // smaller word is occurs at the beginning of the larger word
      return word1.length() - word2.length();
    else
      return 0;
  }
  public static String[] stringArraySort(String[] words) {
    for (int i = 0; i < words.length - 1; i++) {
      for (int j = i + 1; j < words.length; j++) {
        if (compareStrings(words[i], words[j]) > 0) // words[i] is greater than words[j]
        {
          String temp = words[i];
          words[i] = words[j];
          words[j] = temp;
        }
      }
    }
    return words;
  }
  public static void main(String[] args) {
    String[] arrToSort = {"apple", "oranges", "bananas", "Strawberry", "Blueberry"};
    String[] sortedArr = stringArraySort(arrToSort);

    for (int i = 0; i < sortedArr.length; i++) System.out.print(sortedArr[i] + " ");
  }
}

Producción :

Blueberry Strawberry apple bananas oranges

Ordene un array de cadenas utilizando el método `compareTo()` en Java

En el código anterior, escribimos un método que comparará dos cadenas y devolverá un valor entero para indicar qué cadena vendrá primero si estuvieran presentes en un diccionario.

Java nos proporciona un método incorporado llamado compareTo(), que puede hacer este trabajo por nosotros. La sintaxis de este método se muestra a continuación.

string1.compareTo(string2)

La salida de este método es similar al método compareStrings() que definimos anteriormente.

Si cadena1> cadena2: devuelve un entero positivo
Si cadena1 <cadena2: devuelve un entero negativo
Si cadena1 == cadena2: devuelve 0

El siguiente código demuestra cómo funciona el método compareTo() en Java.

public class Main {
  public static void main(String[] args) {
    System.out.println("apple".compareTo("orange")); // apple < orange
    System.out.println("AAA".compareTo("aaa")); // AAA < aaa
    System.out.println("ZZZ".compareTo("aaa")); // ZZZ < aaa
    System.out.println("zzz".compareTo("aaa")); // zzz > aaa
    System.out.println("strawberry".compareTo("strawberry")); // strawberry == strawberry
  }
}

Producción :

Podemos usar el método compareTo() para ordenar matrices. Este programa será muy similar al anterior. La única diferencia es que usaremos el método compareTo() en lugar del método compareStrings() que definimos anteriormente.

public class Main {
  public static String[] stringArraySort(String[] words) {
    for (int i = 0; i < words.length - 1; i++) {
      for (int j = i + 1; j < words.length; j++) {
        if (words[i].compareTo(words[j]) > 0) // words[i] is greater than words[j]
        {
          String temp = words[i];
          words[i] = words[j];
          words[j] = temp;
        }
      }
    }
    return words;
  }
  public static void main(String[] args) {
    String[] arrToSort = {"apple", "oranges", "bananas", "Strawberry", "Blueberry"};
    String[] sortedArr = stringArraySort(arrToSort);
    for (int i = 0; i < sortedArr.length; i++) System.out.print(sortedArr[i] + " ");
  }
}

Producción :

 Blueberry Strawberry apple bananas oranges

Ordene un array de cadenas utilizando el método `Arrays.sort()` en Java

Existe una forma aún más sencilla de ordenar matrices. Podemos usar el método sort() de la clase Arrays para hacer esto. La sintaxis de este método se muestra a continuación.

Arrays.sort(stringArray)

De forma predeterminada, ordenará el array en el orden natural (lexicográficamente). Sin embargo, podemos cambiar este orden especificando diferentes comparadores.

Un comparador es un método que se utiliza para comparar dos objetos y decirnos cuál es más pequeño o más grande que el otro. El método sort() utiliza el algoritmo Quicksort y tiene una complejidad de tiempo de O(n*log(n)).

El siguiente código muestra el comportamiento predeterminado del método sort().

import java.util.Arrays;
public class Main {
  public static void main(String[] args) {
    String[] arrToSort = {"apple", "oranges", "bananas", "Strawberry", "Blueberry"};
    Arrays.sort(arrToSort);
    for (int i = 0; i < arrToSort.length; i++) {
      System.out.print(arrToSort[i] + " ");
    }
  }
}

Producción :

Blueberry Strawberry apple bananas oranges

Ordenar un array de cadenas en orden descendente en Java

Para ordenar el array en el orden natural inverso o en orden descendente, podemos usar el comparador reverseOrder() como se muestra a continuación.

import java.util.Arrays;
import java.util.Collections;

public class Main {
  public static void main(String[] args) {
    String[] arrToSort = {"apple", "oranges", "bananas", "Strawberry", "Blueberry"};
    Arrays.sort(arrToSort, Collections.reverseOrder());
    for (int i = 0; i < arrToSort.length; i++) {
      System.out.print(arrToSort[i] + " ");
    }
  }
}

Producción :

oranges bananas apple Strawberry Blueberry

Ordene un array de cadenas ignorando el caso en Java

Para establecer un array de cadenas en orden alfabético pero ignorar las mayúsculas y minúsculas del carácter, utilice este ejemplo de código a continuación.

import java.util.Arrays;
public class Main {
  public static void main(String[] args) {
    String[] arrToSort = {"apple", "oranges", "bananas", "Strawberry", "Blueberry"};
    Arrays.sort(arrToSort, String.CASE_INSENSITIVE_ORDER); // case insensitive sort
    for (int i = 0; i < arrToSort.length; i++) {
      System.out.print(arrToSort[i] + " ");
    }
  }
}

Producción :

apple bananas Blueberry oranges Strawberry