Classificar um array de string em ordem alfabética em Java

Mohammad Irfan 12 outubro 2023

Java Java String Java Array

Classificar um array de string sem usar métodos integrados em Java
Classificar um array de string usando o método stringArraySort() em Java
Classificar um array de string usando o método compareTo() em Java
Classifique um array de string usando o método Arrays.sort() em Java
Classificar um array de string em ordem decrescente em Java
Classificar um array de string ignorando maiúsculas e minúsculas em Java
Classificar um array de string em ordem alfabética em Java

Classificar um array de string em ordem alfabética em Java

Este tutorial apresenta como classificar matrizes de string em ordem alfabética em Java. Também listamos alguns códigos de exemplo para ajudá-lo a entender o tópico.

Classificar é organizar os dados em uma ordem específica. Podemos classificar os inteiros em ordem crescente ou decrescente, ou podemos classificar os caracteres ou palavras do inglês em ordem lexicográfica.

A ordem lexicográfica é a ordem em que as palavras ocorreriam se estivessem presentes em um dicionário de palavras em inglês. Neste guia, ensinaremos maneiras de classificar um array de string em Java.

Estaremos comparando strings neste artigo com palavras como menor ou maior. Uma string é menor que a outra se ocorrer primeiro de acordo com a ordem lexicográfica.

Além disso, na ordem lexicográfica, todas as letras maiúsculas precedem as minúsculas; isso significa que uma palavra começando com Z estará presente antes de uma palavra começando com a em um array classificada.

Classificar um array de string sem usar métodos integrados em Java

Vamos primeiro tentar implementar nosso próprio método de classificação em Java. Vamos criar um método chamado compareStrings(), que compara duas strings e nos diz qual é menor ou maior.

A seguir, compararemos cada string com todas as outras strings presentes no array usando nosso método compareStrings() e colocaremos essa string em sua posição correta. O algoritmo para os dois métodos é fornecido abaixo.

A entrada para este método será duas strings e ele retornará um valor inteiro. A saída desse método é a seguinte.
- Se string1 > string2: retorna um inteiro positivo
- Se string1 < string2: retorna um inteiro negativo
- Se string1 == string2: retorna 0
Faremos um loop por cada caractere de ambas as strings simultaneamente e compararemos seus valores Unicode. Usamos o método integrado charAt() para obter os valores Unicode. Esses valores nos permitem comparar caracteres como se fossem inteiros normais.
Se os valores Unicode forem iguais para os dois caracteres, passaremos para o próximo caractere de cada string.
Se os valores Unicode forem diferentes, retornamos a diferença dos valores.
O loop termina quando ficamos sem caracteres de qualquer uma das strings.
Se as duas strings têm comprimentos diferentes fora do loop, então retornamos essa diferença. Fazemos isso porque todos os caracteres da string menor podem estar presentes no início da string mais longa. Por exemplo, app e application. Nesse caso, a corda mais longa virá depois da menor.
Se as strings tiverem o mesmo comprimento, simplesmente retornaremos 0, indicando que as duas strings são iguais.

Classificar um array de string usando o método `stringArraySort()` em Java

Este método pegará um array de strings como entrada e retorna o array ordenado. Aqui, teremos dois loops, um aninhado no outro. Eles são usados para comparar cada elemento do array com todos os elementos restantes.

Nós os comparamos usando nosso método compareString() para cada par de elementos dentro do loop. Se a primeira string for maior em comparação com a outra, trocamos suas posições.

O código completo é mostrado abaixo.

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] + " ");
  }
}

Produção:

Blueberry Strawberry apple bananas oranges

Classificar um array de string usando o método `compareTo()` em Java

No código acima, escrevemos um método que comparará duas strings e retornará um valor inteiro para denotar qual string virá primeiro se estiverem presentes em um dicionário.

Java nos fornece um método integrado chamado compareTo(), que pode fazer esse trabalho para nós. A sintaxe desse método é mostrada a seguir.

string1.compareTo(string2)

A saída desse método é semelhante ao método compareStrings() que definimos anteriormente.

Se string1 > string2: retorna um inteiro positivo
Se string1 < string2: retorna um inteiro negativo
Se string1 == string2: retorna 0

O código a seguir demonstra como o método compareTo() funciona em 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
  }
}

Produção:

Podemos usar o método compareTo() para classificar matrizes. Este programa será muito semelhante ao anterior acima. A única diferença é que usaremos o método compareTo() em vez do 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] + " ");
  }
}

Produção:

 Blueberry Strawberry apple bananas oranges

Classifique um array de string usando o método `Arrays.sort()` em Java

Existe uma maneira ainda mais simples de classificar matrizes. Podemos usar o método sort() da classe Arrays para fazer isso. A sintaxe desse método é mostrada a seguir.

Arrays.sort(stringArray)

Por padrão, ele classificará a matriz na ordem natural (lexicograficamente). No entanto, podemos alterar essa ordem especificando comparadores diferentes.

Um comparador é um método usado para comparar dois objetos e nos dizer qual deles é menor ou maior que o outro. O método sort() usa o algoritmo Quicksort e tem uma complexidade de tempo de O(n*log(n)).

O código a seguir mostra o comportamento padrão do 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] + " ");
    }
  }
}

Produção:

Blueberry Strawberry apple bananas oranges

Classificar um array de string em ordem decrescente em Java

Para classificar a matriz na ordem natural reversa ou na ordem decrescente, podemos usar o comparador reverseOrder() como mostrado abaixo.

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] + " ");
    }
  }
}

Produção:

oranges bananas apple Strawberry Blueberry

Classificar um array de string ignorando maiúsculas e minúsculas em Java

Para definir um array de string em ordem alfabética, mas ignorar a caixa do caractere, use este exemplo de código abaixo.

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] + " ");
    }
  }
}

Produção:

apple bananas Blueberry oranges Strawberry