Différentes façons d'inverser une chaîne en Java

Les chaînes en Java peuvent également être considérées comme un tableau de caractères. Les chaînes en Java sont utilisées pour stocker du texte/caractères. Dans le langage de programmation Java, les chaînes sont considérées comme des objets. En Java, les chaînes sont les objets d’une classe prédéfinie nommée String. Toutes les variables chaîne sont des instances de la classe String en Java. Nous pouvons donc comprendre que les chaînes en Java ne sont pas du type primitif comme l'int ou le char dans d'autres langages de programmation. Dans cet article, nous allons lire comment inverser une chaîne en Java. La condition préalable pour cela est que vous sachiez comment créer une chaîne en Java , le concept de base des méthodes de chaîne intégrées et comment effectuer des opérations à l'aide de boucles.

Portée de l'article

- Dans cet article, nous découvrirons les différentes manières d'inverser une chaîne en Java. - Nous verrons également quelques méthodes prédéfinies grâce auxquelles nous pouvons inverser une chaîne en Java. - Nous découvrirons également la complexité temporelle et spatiale de chaque méthode inverse en Java. - Il existe plusieurs façons d'inverser une chaîne en Java, chacune avec ses avantages et ses inconvénients. Dans cet article, nous explorerons certaines des méthodes les plus couramment utilisées pour inverser une chaîne en Java.

Introduction

Les chaînes sont des objets immuables en Java, les chaînes ne sont qu'une séquence de caractères en Java. Les chaînes de lignes simples en Java sont définies avec des guillemets simples tandis que les chaînes de plusieurs lignes en Java sont définies avec des guillemets triples. Java dispose de plusieurs méthodes de chaîne disponibles, mais aujourd'hui, dans cet article, nous allons découvrir les différentes manières d'inverser une chaîne en Java. Le langage de programmation Java est l'un des langages de programmation les plus utilisés au monde et il est connu pour sa simplicité et sa facilité d'utilisation. L'une des opérations les plus courantes que les programmeurs effectuent sur les chaînes consiste à les inverser. Dans cet article, nous aborderons différentes manières d'inverser une chaîne en Java. Tout d’abord, lisons la manière la plus courante d’utiliser la boucle for en Java :

Inversez la chaîne en Java en utilisant la boucle for :

Cette technique est l’un des moyens les plus simples d’inverser une chaîne en Java en utilisant une boucle for. Nous pouvons parcourir les caractères de la chaîne de la fin au début et les ajouter à une nouvelle variable de chaîne. Voici un exemple de comment inverser une chaîne à l’aide d’une boucle 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);
  }
}

Sortir

The reversed string of the s1 is:nuf si avaj

Dans le code ci-dessus, nous avons d'abord pris l'entrée d'une chaîne nommée s1 et créé une chaîne vide s2, puis avons itéré la boucle for à partir du dernier index, puis nous avons stocké la valeur de chaque caractère dans cette chaîne. Exécutez le code ci-dessus dans votre éditeur pour une explication meilleure et plus claire. La complexité temporelle du code ci-dessus est O(N), et comme nous avons parcouru tous les n éléments, la complexité spatiale du code ci-dessus est O(N). Lisons maintenant le prochain processus qui inverse la chaîne à l'aide du générateur de chaînes, alors lisons-le maintenant en détail :

Inverser la chaîne à l'aide de la classe de création de chaîne

Nous pouvons également inverser la chaîne en Java en utilisant la classe StringBuilder. La classe StringBuilder fournit une méthode reverse() qui peut être utilisée pour inverser une chaîne. La méthode reverse() de la classe Java StringBuilder permet de remplacer cette séquence de caractères par l'inverse de la séquence. La classe StringBuilder en Java n'a pas la méthode toCharArray(), tandis que la classe String a la méthode toCharArray(). Comprenons maintenant à l'aide d'un exemple :

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

Sortir

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

Dans cette méthode, nous pouvons voir qu'en utilisant la classe de création de chaîne intégrée, nous avons inversé la chaîne. Cette méthode est très efficace, car elle ne nécessite qu’un seul passage dans la chaîne. Cependant, cela nécessite la création d'un nouvel objet StringBuilder, ce qui peut ajouter une certaine surcharge. Cette méthode est relativement simple et facile à comprendre, mais elle peut être moins efficace que d'autres méthodes, car elle nécessite plusieurs passages dans la chaîne et la création d'une nouvelle chaîne pour chaque caractère. Exécutez le code ci-dessus dans votre éditeur pour une explication meilleure et plus claire. Voyons maintenant une autre façon d'inverser la chaîne en utilisant la technique de récursion :

Inverser la chaîne en utilisant la récursion

La récursivité est une technique dans laquelle une fonction s'appelle elle-même. Nous pouvons utiliser la récursivité pour inverser une chaîne en la décomposant en sous-chaînes plus petites. La récursivité en Java est un processus dans lequel une méthode s'appelle en continu. Pour inverser la chaîne en Java en utilisant la récursion, nous devons d'abord supprimer le premier caractère de la chaîne, puis ajouter ce caractère à la fin de la chaîne, puis nous devons répéter l'étape ci-dessus jusqu'à ce que la chaîne d'entrée devienne vide. Comprenons maintenant cela à l'aide d'un exemple :

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

Sortir

NUF SI AVAJ
AVAJ STCEJBO SGNIRTS
STCEJBO SSALC ELBATUMMI

Par conséquent, nous pouvons voir que dans ce qui précède, en utilisant la récursivité, nous avons inversé la chaîne. Nous avons d'abord vérifié si la chaîne est vide ou non. Si la chaîne est vide, aucun caractère ne peut être inversé. Cette méthode peut être plus efficace que la méthode de la boucle for, car elle ne nécessite qu'un seul passage dans la chaîne. Cependant, cela peut aussi être plus complexe et plus difficile à comprendre, car cela implique l’utilisation de la récursivité . Exécutez le code ci-dessus dans votre éditeur pour une explication meilleure et plus claire. Voyons un autre exemple de la façon d'inverser une chaîne en utilisant la récursivité 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));
}

Voyons maintenant une autre façon d'inverser une chaîne en Java qui utilise le tableau :

Inverser une chaîne en Java à l'aide d'un tableau

Nous pouvons également inverser une chaîne en la convertissant en un tableau de caractères, en modifiant le tableau, puis en la reconvertissant en chaîne. Tout d'abord, nous devons créer un tableau de caractères vide de la même taille que celle de la chaîne donnée, puis nous devons remplir le tableau de caractères à l'envers avec les caractères de la chaîne donnée, et enfin nous devons convertir le tableau de caractères en chaîne en utilisant la méthode de copie et renvoyez-la. Comprenons maintenant cela à l'aide d'un exemple :

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

Sortir

NUF SI AVA

Dans cette méthode, nous devons inverser la chaîne en un tableau de caractères que nous connaissons. Nous allons donc d'abord vérifier si la chaîne est vide ou non et renvoyer si la chaîne est nulle ou vide si elle est égale à vide, puis nous imprimerons simplement la chaîne et break, sinon nous trouverons la longueur de la chaîne, puis nous devrons créer un tableau de caractères de la même taille que celui de la chaîne pour stocker la valeur après l'inversion et en itérant la boucle vers l'arrière, nous devons remplir le tableau de caractères vers l'arrière avec les caractères de la chaîne. et dans la dernière étape après l'inversion, nous devons convertir le tableau de caractères en chaîne et le renvoyer. Exécutez le code ci-dessus dans votre éditeur pour une explication meilleure et plus claire. Voyons maintenant la prochaine étape : nous pouvons également inverser la chaîne en Java à l'aide de l'API Stream. Alors maintenant, lisons-les en détail à l’aide de quelques exemples :

Inversez une chaîne en Java à l'aide de l'API Stream :

Java 8 a introduit l'API Stream qui peut être utilisée pour effectuer des opérations de style fonctionnel sur les collections. Nous pouvons utiliser l'API Stream pour inverser une chaîne en la convertissant en un flux de caractères, en inversant le flux, puis en la reconvertissant en chaîne. Nous pouvons inverser une chaîne en Java en utilisant divers flux et collecteurs. Nous devons d'abord saisir une chaîne, puis utiliser une carte sur la chaîne entière dans un objet StringBuilder et en même temps l'inverser en utilisant la méthode reverse() de la classe StringBuilder et puis enfin, collecter la chaîne inversée à l'aide du Stream. Méthode collect() et collecteurs. join(), nous imprimerons les deux chaînes originales/inversées ainsi que leur longueur. Comprenons maintenant cela à l'aide d'un exemple :

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

Dans cet exemple, nous avons inversé la chaîne en Java en utilisant les flux et les collecteurs Java. Exécutez le code ci-dessus dans votre éditeur pour une explication meilleure et plus claire. Voyons maintenant comment inverser la chaîne en utilisant la pile. Lisons-le maintenant en détail à l'aide d'un exemple :

Inverser la chaîne en utilisant la pile

Il existe une autre façon d’inverser une chaîne en Java : utiliser une pile. L'idée est de pousser chaque caractère de la chaîne d'entrée vers la pile, puis d'extraire les caractères de la pile pour obtenir la chaîne inversée. Lisons maintenant plus en détail à l'aide d'un exemple :

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>

Dans l'exemple ci-dessus, nous avons d'abord créé une pile vide, puis inversé la chaîne et inséré les éléments à l'intérieur de la pile. Cette méthode est simple, facile à comprendre et efficace. Exécutez le code ci-dessus dans votre éditeur pour une explication meilleure et plus claire.

Conclusion

La première méthode consiste à utiliser la classe StringBuilder, qui possède une méthode reverse() intégrée qui renvoie une nouvelle chaîne qui est l'inverse de la chaîne d'origine. La deuxième méthode utilise une boucle for, où nous convertissons la chaîne d'origine en un tableau de caractères et parcourons le tableau dans l'ordre inverse, en attribuant les caractères correspondants à un nouveau tableau de caractères, et enfin en créant une nouvelle chaîne en utilisant ce tableau de caractères. La troisième méthode utilise la récursion, où nous appelons une fonction récursive et résolvons le problème en concaténant le premier caractère de la chaîne avec la sous-chaîne inversée des caractères restants. La quatrième méthode consiste à utiliser un tableau pour inverser une chaîne en Java. Dans la cinquième méthode, nous avons utilisé l'API stream et le collecteur Java pour inverser la chaîne et, dans la dernière méthode, nous avons utilisé la pile pour inverser la chaîne en Java. Chacune de ces méthodes a ses avantages et ses inconvénients, et le choix de la méthode dépend des exigences spécifiques du problème et des préférences du programmeur. Dans l’ensemble, ces méthodes démontrent la flexibilité et la polyvalence de Java dans la manipulation de chaînes.