Comment inverser une chaîne en Java

Une chaîne désigne une séquence de caractères considérée comme un objet en Java. Dans ce langage, il existe plusieurs opérations que vous pouvez effectuer sur l'objet String. L'une des opérations les plus générales sur un objet chaîne est String Reverse, que nous aborderons dans cet article. Voyagez avec nous alors que nous vous montrons quelques approches pour inverser une chaîne en Java.

Nous savons tous que les chaînes sont immuables en Java. Si vous n'avez aucune idée de ce qu'est un objet immuable, son état interne reste constant après avoir été entièrement créé, ce qui signifie aucune modification. En tant que tel, nous ne pouvons pas inverser une chaîne en la modifiant. Pour cette raison, nous devons créer une autre chaîne. Comme nous l'avons dit précédemment, une chaîne est inversée de plusieurs façons. En voici quelques-unes que nous allons vous présenter dans cet article.

• Inversion de chaîne en utilisant l'approche itérative inverse
• Inversion de chaîne utilisant la récursivité
• Inverser les lettres présentes dans la chaîne
• Inversion de chaîne à l'aide de l'approche String Buffer/String Builder
• Utiliser la pile
• Utilisation d'un tableau de caractères
• Utiliser le tableau de caractères et swap()
• Utilisation de l'opérateur + (concaténation de chaînes)
• Utilisation du caractère de remplacement de droite à gauche (RLO) Unicode
• Utiliser un tableau d'octets
• Utilisation de la méthode substring()

Explorons chacune de ces approches, en commençant par comment inverser une chaîne en Java à l'aide de l'approche itérative inverse.

Inverser une chaîne à l'aide d'une itération inverse

Vous allez d'abord convertir la chaîne donnée en tableau de caractères à l'aide de la fonction CharArray() dans cette méthode ou approche. Après cela, itérez le tableau donné dans l'ordre inverse comme indiqué ci-dessous :

import java.util.List;
import java.util.Collections;
import java.util.ArrayList;
import java.util.ListIterator;
 
class Main
{
// Java's Method for reversing a string
Collections.reverse()
    public static String reverseString(String new_str)
    {
// base case: if string is empty or the string is null
        if (new_str == null || new_str.equals("")) {
            return new_str;
        }
 
// initialize an empty characters list
List new_list = new ArrayList();
 
// loop through the given string and push all characters into the new_list
        for (char new_char: str.toCharArray()) {
            new_list.add(new_char);
        }
 
// using java.util.Collections to reverse a list with //reverse()
        Collections.reverse(new_list);
 
// conversion of ArrayList into string using StringBuilder
        StringBuilder str_builder = new StringBuilder(list.size());
        for (Character new_char: list) {
            str_builder.append(new_cha);
        }
 
        return str_builder.toString();
    }
 
    public static void main(String[] args)
    {
        String new_str = "codeunderscored";
 
        // String is immutable
        new_str = reverse(new_str);
 
        System.out.println("Reversed strings is: " + new_str);
    }
}

La chaîne inversée est :derocsrednuedoc

Nous espérons que vous pouvez maintenant comprendre comment utiliser l'itération inverse pour approcher une chaîne dans ce langage de programmation avec l'exemple ci-dessus. Sur ce, allons plus loin et examinons la deuxième approche.

Inversion de chaîne utilisant la récursivité

La récursivité n'est rien de plus qu'une fonction qui s'appelle idéalement elle-même. Nous allons écrire un programme qui inverse la chaîne en s'appelant de manière récursive dans cette approche. Jetons un coup d'œil au programme et vérifions son fonctionnement :

class StringReversal
{
	static int j = 0;

	//  reversing a string using recursive approach in Java using a static variable
	private static void reverseString(char[] new_str, int n)
	{
		// after reaching the end of string
		if (n == new_str.length) {
			return;
		}

		// recur for the next character
		reverse(str, n + 1);

		if (i <= n)
		{
			char temp_val = new_str[k];
			new_str[n] = new_str[i];
			new_str[j++] = temp_val;
		}
	}

	public static String reverseString(String new_str)
	{
		// base case: string is either empty or it is null
		if (new_str == null || str.equals("")) {
			return new_str;
		}

		// convert string into a character array
		char[] A = str.toCharArray();

		// reverse character array
		reverse(A, 0);

		// convert character array into the string
		return String.copyValueOf(A);
	}

	public static void main(String[] args)
	{
		String str = "codeunderscored";

		// string is immutable
		str = reverseString(str);

		System.out.println("Reversed string is: " + str);
	}
}

La chaîne inversée est :derocsrednuedoc

Vous devez noter que dans le programme ci-dessus, nous avons créé l'objet pour la classe StringRecursion r. Ensuite, nous lisons la chaîne saisie à l'aide de la commande sc.nextLine() et la stockons dans la variable chaîne str. En fin de compte, nous avons appelé la méthode inverse comme r.reverseString(str). Gardant cela à l'esprit, nous pouvons pousser l'article plus loin et examiner la méthode suivante d'inversion des chaînes.

Inversion de chaîne à l'aide de l'approche String Buffer/String Builder

StringBuffer et StringBuilder englobent une méthode intégrée reverse() utilisée pour inverser les caractères dans le StringBuffer. Cette méthode substitue la séquence de caractères dans l'ordre inverse. Jetez un œil à l'exemple ci-dessous montrant comment inverser une chaîne à l'aide d'une méthode intégrée de la classe StringBuffer.

class StringReversalUsingStringBuilder
{
	// Reversing a string using `StringBuilder` in Java
	public static String reverseString(String new_str) {
		return new StringBuilder(new_str).reverse().toString();
	}

	public static void main(String[] args)
	{
		String str = "I love codeunderscored";

		// Note that string is immutable in Java
		str = reverse(str);

		System.out.println("Reversed string is: " + str);
	}
}

La chaîne inversée est derocsrednuedoc evol I

C'est tout ce qu'il y a dans la classe d'approche StringBuilder. Nous pouvons également vous guider en utilisant une méthode de classe StringBuffer reverse() tout comme StringBuilder. Allons-y.

Tout d'abord, jetez un œil au programme écrit ci-dessous :

class usingStringBuilder
{
	// Reversing a string in Java using `StringBuffer`
	public static String reverseString(String new_str) {
		return new StringBuffer(new_str).reverse().toString();
	}

	public static void main(String[] args)
	{
		String str = "I love codeunderscored";

		// Note that string is immutable in Java
		str = reverseString(str);

		System.out.println("Reversed string is: " + str);
	}
}

La chaîne inversée est derocsrednuedoc evol I

Notez que vous devriez recevoir la même sortie que celle de la classe StringBuilder lorsque vous exécutez le programme. Un autre point à retenir est que vous pouvez soit inverser en tant que String en utilisant StringBuffer reverseString() comme indiqué dans le code ci-dessus, ou sur l'autre revers de la médaille, vous pouvez utiliser la logique de code comme indiqué ci-dessous :

StringBuffer sb =new StringBuffer("Javacodeunderscored ");
System.out.println(sb.reverse());

Idéalement, StringBuilder et StringBuffer contiennent une approche similaire ou inversent une chaîne en Java. Cependant, StringBuilder est préféré malgré les similitudes car il n'est pas synchronisé et est plus rapide que StringBuffer.

Utiliser la pile

Cette section peut utiliser la structure de données Stack pour aider à inverser une chaîne en Java. Voici les étapes pour y parvenir

Étape 1 : Créez une pile de caractères vide.

Étape 2 : Convertissez la chaîne donnée en un tableau de caractères à l'aide de la méthode String.toCharArray() et poussez chaque caractère pour tenir dans la pile.

Étape 3 : Après cela, retirez des caractères de la pile jusqu'à ce qu'elle soit vide. Ensuite, réaffectez-les au tableau de caractères. Comme la pile suit l'ordre FILO signifiant (premier entré, dernier sorti), les caractères sont insérés dans l'ordre inverse.

Étape 4 : À l'aide de la commande String.copyValueOf(char[]), convertissez le tableau de caractères en chaîne et renvoyez la chaîne créée.

Jetez un œil à l'exemple ci-dessous :

import java.util.Stack;

class usingCopyValueOf
{
	// Method to reverse a string in Java using a stack and character array
	public static String reverseString(String new_str)
	{
		// base case: the string is either empty or null
		if (new_str == null || new_str.equals("")) {
			return new_str;
		}

		// creation of an empty stack of characters
		Stack<Character> stack_char = new Stack<Character>();

		// pushing every character of the given string into the tack
		char[] new_ch = new_str.toCharArray();
		for (int i = 0; i < new_str.length(); i++) {
			stack_char.push(new_ch[i]);
		}

		// index starts from 0
		int n = 0;

		// popping stack characters' till it's empty
		while (!stack_char.isEmpty())
		{
			// assigning every popped character back to the character array
			new_ch[n++] = stack_char.pop();
		}

		// converting the character array into a string and return it
		return String.copyValueOf(new_ch);
	}

	public static void main(String[] args)
	{
		String str = "codeunderscored";

		str = reverse(str);		// string is immutable

		System.out.println("Reversed string is: " + str);
	}
}

La chaîne inversée est :derocsrednuedoc

Sur ce, jetons un coup d'œil à la méthode suivante Utilisation d'un tableau de caractères

Utiliser un tableau de caractères

Comme nous l'avons dit précédemment, vous ne pouvez apporter aucune modification à l'objet chaîne car une chaîne en Java est immuable. Néanmoins, nous pouvons utiliser un tableau de caractères facilement modifiable. Voici les étapes pour y parvenir :

Étape 1 : Génère un tableau de caractères vide de même cardinalité que la chaîne donnée.
Étape 2 : Remplir le tableau de caractères à l'envers avec les caractères de la chaîne donnée
Étape 3 : Enfin, convertissez le tableau de caractères en chaîne à l'aide de cette commande String.copyValueOf(char[]) et renvoyez-le.

Vous trouverez ci-dessous une démonstration des étapes ci-dessus :

class convertUsingCopyValueOf
{
    // reversing a string in Java  with the help of a character array
    public static String reverseString(String new_str)
    {
        // return if the string is either empty or it is is null
        if (new_str == null || new_str.equals("")) {
            return new_str;
        }
 
        // string's length
        int n = new_str.length();
 
        // create a character array of equivalent size to that of the string
        char[] temp_char = new char[n];
 
        // filling character array backward with string's characters
        for (int i = 0; i < n; i++) {
            temp_char[n - i - 1] = new_str.charAt(i);
        }
 
        // converting character array to string and returning it
        return String.copyValueOf(temp_char);
    }
 
    public static void main(String[] args)
    {
        String str = "codeunderscored";
 
        // Strings are immutable in Java
        new_str = reverseString(new_str);
 
        System.out.println("Reversed sring is: " + str);
    }
}   

Utilisation du tableau de caractères et de la méthode swap()

Voici une autre méthode efficace pour inverser une chaîne en Java en utilisant un tableau de caractères :

Étape 1 : Créez un tableau de caractères et modifiez-le avec un ensemble de caractères d'une chaîne donnée à l'aide de String.toCharArray().
Étape 2 : Commencez par les deux extrémités de la chaîne donnée, l et h. Ensuite, exécutez la boucle jusqu'à ce que les deux points mentionnés se croisent (l <=h). Dans chaque itération de boucle, les valeurs d'échange présentent les index l et h et incrémentent l et décrémentent h.
Étape 3 :À la fin, convertissez le tableau de caractères en chaîne en utilisant String.copyValueOf(char[]) et retournez.

Vous trouverez ci-dessous une démonstration de l'explication ci-dessus :

class convertCharacterArrayIntoString
{
	// reversing a string in Java using a character array
	public static String reverseString(String new_str)
	{
		// returns if the string's return either is null or empty
		if (new_str == null || new_str.equals("")) {
			return new_str;
		}

		// creating a character array and initializing it with the specified string
		char[] new_char = new_str.toCharArray();

		for (int l = 0, h = new_str.length() - 1; l < h; l++, h--)
		{
			// swap values at `l` and `h`
			char temp_val = new_char[l];
			new_char[l] = new_char[h];
			new_char[h] = temp_val;
		}

		// convert character array to string and return
		return String.copyValueOf(c);
	}

	public static void main(String[] args)
	{
		String str = "programming with codeunderscored";

		// String is immutable
		str = reverse(str);

		System.out.println("Reversed string is: " + str);
	}
}

La chaîne inversée est :derocsrednuedoc htiw gnimmargorp

Utilisation de l'opérateur + (concaténation de chaînes)

Nous pouvons utiliser l'opérateur de concaténation de chaînes + pour inverser une chaîne en Java en lisant les caractères de l'autre extrémité et en les connectant au début d'une nouvelle chaîne. Notez que pour augmenter les performances de la concaténation de chaînes répétées, un compilateur Java peut utiliser la classe "StringBuffer" ou des formules similaires pour réduire le nombre total d'objets de chaîne intermédiaires générés par l'évaluation de l'expression :

class Main
{
	// Reversing a string in Java using the string concatenation operator
	public static String reverseString(String new_str)
	{
		// return if the string is either empty or null
		if (new_str == null || new_str.equals("")) {
			return new_str;
		}

		// variable storing the reversed string
		String rev_str = "";

		// use string concatenation operator to build a reversed string by
		// read the characters from the end of the original string
		for (int i = new_str.length() - 1; i >=0 ; i--) {
			rev_str += new_str.charAt(i);
		}

		return rev_str;
	}

	public static void main(String[] args)
	{
		String str = "coding made better with codeunderscored";

		str = reverse(str);		// string is immutable

		System.out.println("Reversed string is: " + str);
	}
}

La chaîne inversée est :derocsrednuedoc htiw retteb edam gnidoc

Utilisation du caractère de remplacement de droite à gauche (RLO) Unicode

Dans ce cas, nous pouvons utiliser l'approche de remplacement Unicode de droite à gauche pour convertir une chaîne en son inverse. Pour le présenter, jetez un œil à l'exemple ci-dessous :

class usingUnicode
{
	// reversing a string in Java by Unicode
	// Right-to-left Override (RLO) character
	public static String reverseString(String new_str) {
		return "\u202E" + new_str;
	}

	public static void main(String[] args)
	{
		String str_val = "codeunderscored";

		// string is immutable
		str_val = reverse(str_val);

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

L'inverse de la chaîne donnée est :codeunderscored

Utiliser un tableau d'octets

Dans cette section, l'idée est assez simple. Il suffit de convertir les chaînes données en octets, puis de réorganiser sur place le tableau d'octets comme indiqué dans cette approche. Enfin, nous allons reconvertir le tableau d'octets en une chaîne. Jetez un œil à l'exemple ci-dessous :

import java.util.Arrays;

class usingByteArray
{
	// reversing a string in Java using a byte array
	public static String reverseString(String new_str)
	{
		// return if the specified string is either empty or null
		if (new_str == null || new_str.equals("")) {
			return new_str;
		}

		// converting strings into bytes
		byte[] n_bytes = str.getBytes();

		// starting from the two endpoints `l` and `h` of the given string
		// and increment `l` and decrement `h` at each iteration of the loop
		// until two endpoints intersect (l >= h)
		for (int l = 0, h = new_str.length() - 1; l < h; l++, h--)
		{
			// swap values at `l` and `h`
			byte temp_val = n_bytes[l];
			n_bytes[l] = n_bytes[h];
			n_bytes[h] = temp;
		}

		// convert byte array back into a string
		return new String(bytes);
	}

	public static void main(String[] args)
	{
		String str = "reverse codeunderscored";

		// String is immutable
		str = reverse(str);

		System.out.println("Reversed string is: " + str);
	}
}

La chaîne inversée est :derocsrednuedoc esrever

Utilisation de la méthode Substring()

Nous pouvons également utiliser l'approche String.substring(int, int) pour obtenir une inversion sur une chaîne en Java. Le code suivant utilise la méthode String.charAt(int) pour séparer le premier ou le dernier caractère de et se reproduire pour la chaîne restante à l'aide de substring()

Méthode 1 :

class reverseUsingRecursion
{
	//  reversing a string in Java through recursion
	private static String reverseString(String new_str)
	{
		// base case: returns if given string is empty or null
		if (new_str == null || new_str.equals("")) {
			return new_str;
		}

		// last character + recur for the remaining string
		return new_str.charAt(new_str.length() - 1) +
				reverseString(new_str.substring(0, new_str.length() - 1));
	}

	public static void main(String[] args)
	{
		String str = "codeunderscored solves";

		// string is immutable
		str = reverse(str);

		System.out.println("Reversed string is: " + str);
	}
}

La chaîne inversée est :sevlos derocsrednuedoc

Méthode 2 :

class reverseUsingRecursion
{
	// reversing a string in Java using recursion
	public static String reverseString(String new_str)
	{
		// base case:  check if the string is null or empty
		if (new_str == null || new_str.equals("")) {
			return new_str;
		}

		// isolate the first character and recur for the remaining string
		return reverseString(new_str.substring(1)) + new_str.charAt(0);
	}

	public static void main(String[] args)
	{
		String str = "Reverse codeunderscored";

		// string is immutable
		new_str = reverseString(new_str);

		System.out.println("Reversed string is: " + new_str);
	}
}

La chaîne inversée est :derocsrednuedoc esreveR

C'est tout ce qu'il y a à inverser les lettres dans une chaîne donnée.

Conclusion

Rien de mieux que d'avoir la flexibilité de faire quoi que ce soit avec votre code, et c'est exactement ce que nous vous avons donné dans cet article. Nous avons examiné les différentes approches pour inverser une chaîne en Java. Nous avons exploré plusieurs exemples avec un peu d'explication pour vous aider à démarrer. Nous espérons que les méthodes abordées ici ont répondu à certaines questions rhétoriques sur l'inversion de chaîne en Java.