Diferentes maneiras de reverter uma string em Java

Strings em java também podem ser consideradas uma matriz de caracteres. Strings em java são usadas para armazenar texto/caracteres. Na linguagem de programação java, as strings são consideradas objetos. Em Java, strings são objetos de uma classe predefinida chamada String. Todas as variáveis ​​​​string são instâncias da classe String em java. Portanto, podemos entender que as strings em java não são de tipos primitivos como int ou char em outras linguagens de programação. Neste artigo, leremos como reverter uma string em java. O pré-requisito para isso é que você saiba como criar uma string em java , e o conceito básico de métodos de string embutidos, e como realizar operações com a ajuda de loops.

Escopo do artigo

- Neste artigo, leremos sobre as várias maneiras de reverter uma string em java. - Veremos também alguns métodos pré-construídos através dos quais podemos reverter uma string em java. - Também leremos sobre a complexidade de tempo e espaço de cada método reverso em java. - Existem diversas maneiras de reverter uma string em Java, cada uma com suas vantagens e desvantagens. Neste artigo, exploraremos alguns dos métodos mais comumente usados ​​para reverter uma string em Java.

Introdução

Strings são objetos imutáveis ​​em java, strings são apenas uma sequência de caracteres em java. Strings de linhas simples em java são definidas com aspas simples, enquanto strings de linhas múltiplas em java são definidas com aspas triplas. Java tem vários métodos de string disponíveis, mas hoje neste artigo leremos sobre as diferentes maneiras de reverter uma string em java. A linguagem de programação Java é uma das linguagens de programação mais utilizadas no mundo e é conhecida por sua simplicidade e facilidade de uso. Uma das operações mais comuns que os programadores realizam em strings é revertê-las. Neste artigo, discutiremos diferentes maneiras de reverter uma string em Java. Primeiro, vamos ler sobre a maneira mais comum de usar o loop for em java:

Inverta a string em java usando o loop for:

Essa técnica é uma das maneiras mais simples de reverter uma string em Java usando um loop for. Podemos iterar pelos caracteres da string do final ao início e adicioná-los a uma nova variável de string. Aqui está um exemplo de como reverter uma string usando um loop for :

//in the above code we have reversed the string using a for loop in java
public class reverseofthestring {
  public static void main(String[] args) {

    String s1 = "java is fun";
      // we are creating the second string to store the reversed string and print it while iterating the for loop
    String s2 = "";

    for(int i = s1.length()-1; i>=0; i--)
    {
        // in the above line we have stored the reversed string by iterating the for loop from the last index and stored the value in the second string created s2.
      s2 = s2 + s1.charAt(i);
    }

    System.out.print("The reversed string of the '"+s1+"' is: " );
    System.out.println(s2);
  }
}

Saída

The reversed string of the s1 is:nuf si avaj

No código acima, primeiro pegamos a entrada de uma string chamada s1 e criamos uma string vazia s2 e, em seguida, iteramos o loop for do último índice e então armazenamos o valor de cada caractere nessa string. Execute o código acima em seu editor para uma explicação melhor e clara. A complexidade de tempo do código acima é O(N) e, como iteramos todos os n elementos, a complexidade de espaço do código acima é O(N). Agora vamos ler sobre o próximo processo que é reverter a string usando o construtor de string, então vamos ler sobre isso em detalhes:

Revertendo a string usando a classe construtor de string

Também podemos reverter a string em Java usando a classe StringBuilder. A classe StringBuilder fornece um método reverse() que pode ser usado para reverter uma string. O método reverse() da classe Java StringBuilder é usado para substituir esta sequência de caracteres pelo inverso da sequência. A classe StringBuilder em java não possui o método toCharArray(), enquanto a classe String possui o método toCharArray(). Agora vamos entender com a ajuda de um exemplo:

public class reverseusingbuilder {
    public static void main(String[] args) {
        StringBuilder s1 = new StringBuilder("abc");
        System.out.println("The original string1 is  = " + s1);
        StringBuilder s2 = new StringBuilder("cab");
        System.out.println("The original string2 is = " + s2);
         StringBuilder s3 = new StringBuilder("wer");
        System. out.println("The original string3 is = " + s3);
        // reversing of stringbuilder
        System.out.println("The reverse of the string is reverse1 = " + s1.reverse());
        System.out.println("The reverse of the string2 is reverse2 = " + s2.reverse());
         System.out.println("The reverse of the string3 is reverse2 = " + s3.reverse());
    }
}

Saída

The original string1 is  = abc
The original string2 is  =cab
The original string3 is  =wer
The reversed string1 is  = cba
The reversed string2 is  = bac
The reversed string3 is  =rew

Neste método, podemos ver que usando a classe construtora de string embutida, invertemos a string. Este método é muito eficiente, pois requer apenas uma única passagem pela string. No entanto, requer a criação de um novo objeto StringBuilder, que pode adicionar alguma sobrecarga. Este método é relativamente simples e fácil de entender, mas pode ser menos eficiente que outros métodos, pois requer múltiplas passagens pela string e a criação de uma nova string para cada caractere. Execute o código acima em seu editor para uma explicação melhor e clara. Agora vamos ver outra maneira de reverter a string usando a técnica de recursão:

Inverta a string usando recursão

A recursão é uma técnica na qual uma função chama a si mesma. Podemos usar a recursão para reverter uma string, dividindo-a em substrings menores. A recursão em java é um processo no qual um método chama a si mesmo continuamente. Para reverter a string em java usando recursão, primeiro temos que remover o primeiro caractere da string e, em seguida, anexar esse caractere no final da string e então temos que repetir a etapa acima até que a string de entrada fique vazia. Agora vamos entender isso com a ajuda de um exemplo:

public class reverse string
{
//in this line we are writing the recursive function to reverse a string
public String reverse string(String s1)
{
//first we will check if the string is empty or not
if(s1.isEmpty())
{
System. out.println("String is empty.")
//if the above condition is true then it returns the same string as if the string is empty itself then we cannot reverse the string
return s1;
}
else
{
return reverseString(s1.substring(1))+s1.charAt(0);
}
}
public static void main(String[] args)
{
reversestring q1 = new reversestring();
String res1 = q1.reverseString("JAVA IS FUN");
String res2 = q1.reverseString("STRINGS OBJECTS JAVA");
String res3 = q1.reverseString("IMMUTABLE CLASS OBJECTS");
System.out.println(res1);
System.out.println(res2);
System.out.println(res3);
}
}

Saída

NUF SI AVAJ
AVAJ STCEJBO SGNIRTS
STCEJBO SSALC ELBATUMMI

Portanto, podemos ver que acima, usando a recursão, invertemos a string, primeiro verificamos se a string está vazia ou não, se a string estiver vazia, então não haverá caracteres que possam ser revertidos. Este método pode ser mais eficiente que o método for-loop, pois requer apenas uma única passagem pela string. Porém, também pode ser mais complexo e difícil de entender, pois envolve o uso de recursão . Execute o código acima em seu editor para uma explicação melhor e clara. Vejamos outro exemplo de como reverter uma string usando recursão em java:

public static String reverseusingrecursion(String s1) {
    if (s1.length() == 1) {
        return s1;
    }
    //We have applied recursion in this line
    return s1.charAt(s1.length() - 1) + reverseUsingRecursion(s1.substring(0, s1.length() - 1));
}

Agora vamos ler sobre outra maneira de reverter uma string em java que usa o array:

Reverter uma string em java usando um array

Também podemos reverter uma string convertendo-a em uma matriz de caracteres, alterando a matriz e depois convertendo-a novamente em uma string. Primeiro, temos que criar uma matriz de caracteres vazia do mesmo tamanho da string fornecida, depois temos que preencher a matriz de caracteres de trás para frente com os caracteres da string fornecida e, finalmente, temos que converter a matriz de caracteres na string usando o método copy e retorne-o. Agora vamos entender isso com a ajuda de um exemplo:

public class Main
{
    // In this Method of conversion we have to reverse a string in Java using a character array
    public static String reverse(String s1)
    {
        // we have to check if the string is empty or not and return if the string is null or empty
        if (s1 == null || s1.equals("")) {
            return s1;
        }
 // if it is equal to empty then we will simply print the string and break it.
        // else we will find the string length
        int len = str.length();

        // and then we have to create a character array of the same size as that of the string to store the value after reversing
        char[] new_arr = new char[n];

        // and by iterating the loop backward we have to fill the character array backward with characters in the string
        for (int i = 0; i < len; i++) {
            new_arr[len - i - 1] = str.charAt(i);
        }

        // and in the final step after reversing we have to convert the character array to string and return it
        to return String.copy value of(new_arr);
    }

    public static void main(String[] args)
    {
        // taking a string input for reverse
        String s1 = "JAVA IS FUN";

        // In this line we are calling the reverse function and reversing the string
        str = reverse(str);

        System.out.println("The reversed string is " + s1);
    }
}

Saída

NUF SI AVA

Neste método temos que reverter a string para um array de caracteres que conhecemos, então primeiro verificaremos se a string está vazia ou não e retornaremos se a string for nula ou vazia se for igual a vazia então simplesmente imprimiremos a string e break else encontraremos o comprimento da string e então teremos que criar uma matriz de caracteres do mesmo tamanho da string para armazenar o valor após a reversão e iterando o loop para trás temos que preencher a matriz de caracteres para trás com caracteres na string e na etapa final, após a reversão, temos que converter o array de caracteres em string e retorná-lo. Execute o código acima em seu editor para uma explicação melhor e clara. Agora vamos ler sobre a próxima etapa, também podemos reverter a string em java usando a API Stream. Então agora vamos ler sobre eles em detalhes com a ajuda de alguns exemplos:

Reverta uma string em java usando a API Stream:

Java 8 introduziu a API Stream que pode ser usada para executar operações de estilo funcional em coleções. Podemos usar a API Stream para reverter uma string convertendo-a em um fluxo de caracteres, revertendo o fluxo e, em seguida, convertendo-a novamente em uma string. Podemos reverter uma string em java usando vários fluxos e coletores, primeiro temos que inserir uma string e então usar um Map em toda a String em um objeto StringBuilder e ao mesmo tempo revertê-lo usando o método reverse() da classe StringBuilder e então, finalmente, coletando a String invertida usando o Stream. método collect() e coletores. método join() imprimiremos ambas as Strings originais/invertidas junto com seu comprimento. Agora vamos entender isso com a ajuda de um exemplo:

public static String reverseUsingStream(String str) {
    return str. chars()
              .mapToObj(c -> (char) c)
              .collect(StringBuilder::new, StringBuilder::append, StringBuilder::append)
              .reverse()
              .toString();
}

Neste exemplo, invertemos a string em java usando os fluxos e coletores java. Execute o código acima em seu editor para uma explicação melhor e clara. Agora vamos ver como podemos reverter a string usando a pilha. Agora vamos ler sobre isso em detalhes com a ajuda de um exemplo:

Inverta a string usando a pilha

Existe outra maneira de reverter uma string em Java: usando uma pilha. A ideia é colocar cada caractere da string de entrada na pilha e, em seguida, retirar os caracteres da pilha para obter a string invertida. Agora vamos ler mais sobre isso em detalhes com a ajuda de um exemplo:

public static String reverse string(String input) {
    Stack<character> stack = new Stack<>();
    for (int i = 0; i < input.length(); i++) {
        stack.push(input.charAt(i));
    }
    StringBuilder sb = new StringBuilder();
    while (!stack.isEmpty()) {
        sb.append(stack.pop());
    }
    return sb.toString();
}

</character>

No exemplo acima, primeiro criamos uma pilha vazia e depois invertemos a string e inserimos os elementos dentro da pilha. Este método é simples, fácil de entender e eficiente. Execute o código acima em seu editor para uma explicação melhor e clara.

Conclusão

O primeiro método é usar a classe StringBuilder, que possui um método reverse() integrado que retorna uma nova string que é o inverso da string original. O segundo método é usar um loop for, onde convertemos a string original em um array char e iteramos pelo array na ordem inversa, atribuindo os caracteres correspondentes a um novo array char e, finalmente, criando uma nova string usando esse array char. O terceiro método é usar recursão, onde chamamos uma função recursiva e resolvemos o problema concatenando o primeiro caractere da string com a substring invertida dos caracteres restantes. O quarto método é usar um array para reverter uma string em java. No quinto método, usamos a API stream e o coletor java para reverter a string e, no último método usamos a pilha para reverter a string em java. Cada um desses métodos tem suas vantagens e desvantagens, e a escolha do método depende dos requisitos específicos do problema e da preferência do programador. No geral, esses métodos demonstram a flexibilidade e versatilidade do Java na manipulação de strings.