Diferentes formas de invertir una cadena en Java

Las cadenas en Java también se pueden decir como una matriz de caracteres. Las cadenas en Java se utilizan para almacenar texto/caracteres. En el lenguaje de programación Java, las cadenas se consideran objetos. En Java, las cadenas son objetos de una clase predefinida llamada String. Todas las variables de cadena son instancias de la clase String en Java. Por lo tanto, podemos entender que las cadenas en Java no son de tipos primitivos como int o char en otros lenguajes de programación. En este artículo, leeremos cómo invertir una cadena en Java. El requisito previo para esto es que sepas cómo crear una cadena en Java y el concepto básico de los métodos de cadena incorporados, y cómo realizar operaciones con la ayuda de bucles.

Alcance del artículo

- En este artículo, leeremos sobre las diversas formas de invertir una cadena en Java. - También veremos algunos métodos prediseñados mediante los cuales podemos invertir una cadena en Java. - También leeremos sobre la complejidad temporal y espacial de cada método inverso en Java. - Hay varias formas de invertir una cadena en Java, cada una con sus ventajas y desventajas. En este artículo, exploraremos algunos de los métodos más utilizados para invertir una cadena en Java.

Introducción

Las cadenas son objetos inmutables en Java, las cadenas son solo una secuencia de caracteres en Java. Las cadenas de líneas simples en Java se definen con comillas simples, mientras que las cadenas de líneas múltiples en Java se definen con comillas triples. Java tiene varios métodos de cadenas disponibles, pero hoy en este artículo leeremos sobre las diferentes formas de invertir una cadena en Java. El lenguaje de programación Java es uno de los lenguajes de programación más utilizados en el mundo y es conocido por su simplicidad y facilidad de uso. Una de las operaciones más comunes que realizan los programadores con cadenas es invertirlas. En este artículo, analizaremos diferentes formas de invertir una cadena en Java. Primero, leamos sobre la forma más común de usar el bucle for en Java:

Invierte la cadena en java usando el bucle for:

Esta técnica es una de las formas más sencillas de invertir una cadena en Java mediante el uso de un bucle for. Podemos recorrer los caracteres de la cadena desde el final hasta el principio y agregarlos a una nueva variable de cadena. Aquí hay un ejemplo de cómo invertir una cadena usando un bucle 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);
  }
}

Producción

The reversed string of the s1 is:nuf si avaj

En el código anterior, primero tomamos la entrada de una cadena llamada s1 y creamos una cadena vacía s2 y luego iteramos el bucle for desde el último índice y luego almacenamos el valor de cada carácter en esa cadena. Ejecute el código anterior en su editor para obtener una explicación mejor y clara. La complejidad temporal del código anterior es O (N) y, como hemos iterado sobre los n elementos, la complejidad espacial del código anterior es O (N). Ahora leamos sobre el siguiente proceso que es invertir la cadena usando el generador de cadenas, así que ahora leamos sobre ello en detalle:

Invertir la cadena usando la clase de creación de cadenas

También podemos invertir la cadena en Java usando la clase StringBuilder. La clase StringBuilder proporciona un método inverso() que se puede utilizar para invertir una cadena. El método inverso() de la clase Java StringBuilder se utiliza para reemplazar esta secuencia de caracteres con el reverso de la secuencia. La clase StringBuilder en Java no tiene el método toCharArray(), mientras que la clase String sí tiene el método toCharArray(). Ahora entendamos con la ayuda de un ejemplo:

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());
    }
}

Producción

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

En este método, podemos ver que utilizando la clase de creación de cadenas incorporada hemos invertido la cadena. Este método es muy eficiente, ya que solo requiere un paso a través de la cuerda. Sin embargo, requiere la creación de un nuevo objeto StringBuilder, lo que puede agregar algo de sobrecarga. Este método es relativamente simple y fácil de entender, pero puede ser menos eficiente que otros métodos, ya que requiere múltiples pasadas por la cadena y la creación de una nueva cadena para cada carácter. Ejecute el código anterior en su editor para obtener una explicación mejor y clara. Ahora veamos otra forma de invertir la cadena usando la técnica de recursividad:

Invertir la cadena usando recursividad

La recursividad es una técnica en la que una función se llama a sí misma. Podemos usar la recursividad para invertir una cadena dividiéndola en subcadenas más pequeñas. La recursividad en Java es un proceso en el que un método se llama a sí mismo continuamente. Para invertir la cadena en Java usando recursividad, primero debemos eliminar el primer carácter de la cadena y luego agregar ese carácter al final de la cadena y luego debemos repetir el paso anterior hasta que la cadena de entrada quede vacía. Ahora entendamos esto con la ayuda de un ejemplo:

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);
}
}

Producción

NUF SI AVAJ
AVAJ STCEJBO SGNIRTS
STCEJBO SSALC ELBATUMMI

Por lo tanto, podemos ver que en lo anterior, al usar la recursividad hemos invertido la cadena. Primero hemos verificado si la cadena está vacía o no. Si la cadena estará vacía, entonces no habrá caracteres que se puedan invertir. Este método puede ser más eficiente que el método del bucle for, ya que solo requiere un paso a través de la cadena. Sin embargo, también puede ser más complejo y difícil de entender, ya que implica el uso de recursividad . Ejecute el código anterior en su editor para obtener una explicación mejor y clara. Veamos otro ejemplo de cómo invertir una cadena usando recursividad en 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));
}

Ahora leamos sobre otra forma de invertir una cadena en Java que utiliza la matriz:

Invertir una cadena en java usando una matriz

También podemos revertir una cadena convirtiéndola en una matriz de caracteres, cambiando la matriz y luego convirtiéndola nuevamente en una cadena. Primero, tenemos que crear una matriz de caracteres vacía del mismo tamaño que la de la cadena dada, luego tenemos que llenar la matriz de caracteres hacia atrás con caracteres de la cadena dada y finalmente tenemos que convertir la matriz de caracteres en una cadena usando el método de copia y devolverlo. Ahora entendamos esto con la ayuda de un ejemplo:

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);
    }
}

Producción

NUF SI AVA

En este método tenemos que invertir la cadena a una matriz de caracteres que conocemos, así que primero verificaremos si la cadena está vacía o no y devolveremos si la cadena es nula o vacía, si es igual a vacía, luego simplemente imprimiremos la cadena y de lo contrario, encontraremos la longitud de la cadena y luego tendremos que crear una matriz de caracteres del mismo tamaño que la cadena para almacenar el valor después de invertir y, al iterar el bucle hacia atrás, tenemos que llenar la matriz de caracteres hacia atrás con caracteres en la cadena. y en el paso final después de revertir tenemos que convertir la matriz de caracteres en una cadena y devolverla. Ejecute el código anterior en su editor para obtener una explicación mejor y clara. Ahora leamos sobre el siguiente paso: también podemos invertir la cadena en Java usando la API Stream. Ahora leamos sobre ellos en detalle con la ayuda de algunos ejemplos:

Invierta una cadena en Java usando Stream API:

Java 8 introdujo la Stream API que se puede utilizar para realizar operaciones de estilo funcional en colecciones. Podemos usar la API Stream para invertir una cadena convirtiéndola en una secuencia de caracteres, invirtiendo la secuencia y luego convirtiéndola nuevamente en una cadena. Podemos revertir una cadena en Java usando varias secuencias y recopiladores. Primero tenemos que ingresar una cadena y luego usar un mapa en toda la cadena en un objeto StringBuilder y al mismo tiempo revertirlo usando el método inverso() de la clase StringBuilder. luego, finalmente, recolectar la cadena invertida usando Stream. Método Collect() y coleccionistas. método join() imprimiremos ambas cadenas originales/invertidas junto con su longitud. Ahora entendamos esto con la ayuda de un ejemplo:

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

En este ejemplo, hemos invertido la cadena en Java utilizando los flujos y recopiladores de Java. Ejecute el código anterior en su editor para obtener una explicación mejor y clara. Ahora veamos cómo podemos invertir la cadena usando la pila. Ahora leamos sobre esto en detalle con la ayuda de un ejemplo:

Invierte la cadena usando la pila.

Hay otra forma de invertir una cadena en Java que es mediante el uso de una pila. La idea es enviar cada carácter de la cadena de entrada a la pila y luego extraer caracteres de la pila para obtener la cadena invertida. Ahora leamos más sobre esto en detalle con la ayuda de un ejemplo:

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>

En el ejemplo anterior, primero creamos una pila vacía y luego invertimos la cadena e insertamos los elementos dentro de la pila. Este método es simple, fácil de entender y eficiente. Ejecute el código anterior en su editor para obtener una explicación mejor y clara.

Conclusión

El primer método es utilizar la clase StringBuilder, que tiene un método inverso() incorporado que devuelve una nueva cadena que es el reverso de la cadena original. El segundo método consiste en utilizar un bucle for, donde convertimos la cadena original en una matriz de caracteres e iteramos a través de la matriz en orden inverso, asignando los caracteres correspondientes a una nueva matriz de caracteres y finalmente creando una nueva cadena usando esa matriz de caracteres. El tercer método utiliza la recursividad, donde llamamos a una función recursiva y resolvemos el problema concatenando el primer carácter de la cadena con la subcadena invertida de los caracteres restantes. El cuarto método consiste en utilizar una matriz para invertir una cadena en Java. En el quinto método, usamos la API de transmisión y el recopilador de Java para invertir la cadena y, en el último método, usamos la pila para invertir la cadena en Java. Cada uno de estos métodos tiene sus ventajas y desventajas, y la elección del método depende de los requisitos específicos del problema y de las preferencias del programador. En general, estos métodos demuestran la flexibilidad y versatilidad de Java en la manipulación de cadenas.