Inverser une chaîne en Java

Hé! Bienvenue dans la deuxième édition de la série Inverser une chaîne dans chaque langue. Dans cet article, nous abordons Inverser une chaîne en Java. Bouclez votre ceinture car celle-ci est longue !

Inverser une chaîne en Java

Comme d'habitude, examinons directement la solution complète d'inversion d'une chaîne en Java :

public class ReverseString {
  public static void main(String args[]) {
    if (args.length > 0) {
      StringBuilder builder = new StringBuilder(args[0]);
      String reversed = builder.reverse().toString();
      System.out.println(reversed);
    }
  }
}

Si vous avez déjà lu cet article, vous vous souvenez peut-être de l'extrait suivant :

public class ReverseString {

  public static String reverse(String toReverse) {
    char[] characters = toReverse.toCharArray();
    int start = 0;
    int end = characters.length - 1;
    char temp;
    while(end > start){
      temp = characters[start];
      characters[start] = characters[end];
      characters[end] = temp;
      end--;
      start++;
    }
    return new String(characters);
  }

  public static void main(String args[]) {
    if (args.length > 0) {
      System.out.println(reverse(args[0]));
    }
  }
}

Il s'avère que l'extrait ci-dessus fonctionne mais présente quelques pièges. Le principal écueil étant que cela ne fonctionne pas pour les jeux de caractères spéciaux tels que le chinois. Cependant, je prévois de garder son explication pour montrer la langue.

Quoi qu'il en soit, allons-y !

La solution générale

Comme nous pouvons le voir, la solution générale exploite la bibliothèque StringBuilder pour inverser une chaîne en Java. À l'origine, j'étais contre cette idée car elle cache vraiment certaines des fonctionnalités intéressantes de Java. Cependant, cette méthode est de loin supérieure à celle que j'ai partagée auparavant car elle fonctionne pour chaque chaîne que vous lui lancez.

Quoi qu'il en soit, allons-y.

La déclaration de classe

Comme tout programme Java, nous sommes obligés de créer une classe avant de pouvoir faire quoi que ce soit :

public class ReverseString {
  // Insert code here
}

Comme restriction supplémentaire, nous sommes également bloqués en utilisant le même nom pour le fichier :ReverseString.java.

La déclaration de méthode principale

Encore une fois, si nous voulons un programme exécutable en Java, nous devrons créer une méthode principale :

public static void main(String args[]) {
  // Insert code here
}

La structure principale de la méthode est toujours la même.

Tout d'abord, nous déclarons une méthode statique publique, ce qui signifie que toute personne ayant accès à la classe peut exécuter cette méthode sans créer d'instance de la classe. Bien sûr, personne ne fait cela avec les méthodes principales, mais vous voyez l'idée.

Ensuite, nous déclarons un type de retour de void. Dans certains langages, nous pouvons renvoyer un entier, mais en Java, nous ne renvoyons rien. C'est juste la convention.

Enfin, nous utilisons le nom de la méthode principale et déclarons un tableau String comme entrée. Le tableau d'entrée sera la façon dont nous accédons à nos arguments de ligne de commande.

Le cœur de la méthode principale

Jusqu'à présent, tout était exactement le même dans les deux solutions. En d'autres termes, si vous n'aimez pas la façon dont quelque chose est formulé jusqu'à présent, consultez ci-dessous pour une autre explication.

Ensuite, nous allons jeter un œil à l'intérieur de la méthode principale :

if (args.length > 0) {
  StringBuilder builder = new StringBuilder(args[0]); 
  String reversed = builder.reverse().toString(); 
  System.out.println(reversed);
}

Tout ce que nous faisons vraiment ici, c'est vérifier que nous avons des arguments de ligne de commande. Si nous le faisons, nous essayons de les inverser et de les imprimer à l'utilisateur, c'est aussi simple !

Bien sûr, au lieu d'inverser la chaîne à l'aide du tableau de caractères, nous exploitons la bibliothèque StringBuilder qui gère les substituts pour nous. En d'autres termes, nous n'avons pas à nous soucier de corrompre les chaînes.

Cependant, c'est une explication plutôt de haut niveau. Si nous regardons de plus près, nous créons un StringBuilder en utilisant le premier argument de ligne de commande. Ensuite, nous appelons la méthode reverse de StringBuilder qui inverse la String. À ce stade, nous reconvertissons notre StringBuilder en String et le renvoyons. Terminé !

La solution incomplète

Si vous avez déjà lu cet article, vous savez que j'ai implémenté l'inversion de chaîne à la main. En d'autres termes, j'ai utilisé une boucle pour échanger des caractères dans le tableau de caractères. Malheureusement, cette solution est incomplète, mais je pense qu'elle présente de nombreuses fonctionnalités intéressantes de Java. Donc, je garde la répartition du code ci-dessous.

La déclaration de classe

Comme pour tout programme en Java, notre première étape consiste à créer une classe :

public class ReverseString {
  // Insert code here
}

Dans ce cas, j'ai créé une classe publique avec le nom ReverseString. Par conséquent, le fichier doit également partager ce nom.

La déclaration de méthode principale

Dans la classe, j'ai déclaré deux méthodes. La première méthode sur laquelle je veux me concentrer est la méthode principale vers le bas. Cette méthode est l'endroit où le programme tombe lorsque nous l'exécutons :

public static void main(String args[]) {
  // Insert code here
}

Comme nous pouvons le voir, la méthode principale est déclarée publique et statique, ce qui signifie que n'importe qui peut y accéder sans instance de la classe ReverseString. De plus, la méthode main a un type de retour void. En d'autres termes, la méthode ne renvoie rien.

En termes de paramètres, la méthode principale de Java doit accepter un tableau de chaînes. Ce tableau contient chacun des arguments de la ligne de commande. Cependant, contrairement à Python, le premier argument n'est pas réservé au nom du fichier. En fait, il est possible que le tableau d'arguments soit vide.

Le code de la méthode principale

C'est à l'intérieur de la méthode principale que la magie opère :

if (args.length > 0) {
  System.out.println(reverse(args[0]));
}

Ici, nous pouvons voir une instruction if et une instruction print. Selon la logique conditionnelle, nous n'exécutons l'instruction print que si la liste des arguments n'est pas vide. Pour ce faire, nous vérifions que la longueur de la liste des arguments est supérieure à zéro.

Dans le cas où nous avons un argument, nous exécutons notre déclaration d'impression. À ce stade, nous devons appeler reverse, notre méthode reverse a string. Notez que nous passons toujours le premier argument. Tous les autres arguments sont ignorés.

La déclaration de méthode inverse

Pour avoir une meilleure idée de ce que fait la méthode principale, nous devons creuser dans la déclaration de la méthode inverse.

La méthode inverse est très similaire à notre méthode principale en ce sens qu'elle est également publique et statique. Cela signifie que nous pourrions appeler la méthode reverse sans instance de la classe ReverseString :

ReverseString.reverse("Hello, World!")  // returns "!dlroW ,olleH"

L'avantage ici est que nous pouvons appeler reverse directement dans la méthode main.

Contrairement à la méthode principale, la méthode inverse renvoie une chaîne. Cela a probablement du sens puisque nous voulons que la méthode inverse nous donne une chaîne inversée.

Par conséquent, la méthode inverse prend également une chaîne en entrée. En d'autres termes, la méthode inverse prend une chaîne et génère l'inverse de cette chaîne, comme indiqué dans l'extrait ci-dessus.

La chaîne de transformation en tableau de caractères

Maintenant, quand j'ai écrit cette solution, j'ai spécifiquement évité la bibliothèque StringBuilder car elle masque complètement l'inversion de String :

new StringBuilder(toReverse).reverse().toString()

Remarquez comment nous aurions pu facilement envelopper notre chaîne dans un StringBuilder, appelé la méthode inverse, et la reconvertir en une chaîne. Bien sûr, je pense que cela va à l'encontre du but de cette série.

Au lieu de cela, nous commençons par convertir notre chaîne d'entrée en un tableau de caractères :

// i.e. ['H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!'] 
char[] characters = toReverse.toCharArray();

Un tableau de caractères est simplement un ensemble de caractères que nous pouvons manipuler librement. Normalement, nous ne pouvons pas manipuler les caractères dans une chaîne car les chaînes sont immuables en Java. Cela signifie que toute modification apportée à une chaîne entraîne la création d'une nouvelle chaîne.

Les variables locales

Avant de pouvoir réellement commencer à inverser ce tableau de caractères, nous définissons et déclarons quelques variables :

int start = 0;
int end = characters.length - 1;
char temp;

Comme nous pouvons probablement l'imaginer, commencer et fin se référer aux indices au début et à la fin du tableau de caractères. Le temp sera utilisée pour suivre les swaps. Nous verrons cela jouer plus tard.

La structure de la boucle

Bon, alors maintenant nous allons effectuer la manipulation String. Pour ce faire, nous devons créer une boucle :

while(end > start) {
  // Insert code here
}

Notre condition de boucle est assez simple. Tout ce que nous faisons, c'est surveiller le démarrage et fin variables. Si à tout moment commencez traverse fin , nous sortons de la boucle. Comme nous pouvons probablement l'imaginer, nous allons manipuler start et fin à l'intérieur de la boucle.

Les éléments internes de la boucle

À l'intérieur de la boucle, nous échangeons à peu près simplement les caractères au début et fin index et déplacez ces pointeurs vers l'intérieur d'une unité :

temp = characters[start];
characters[start] = characters[end];
characters[end] = temp;
end--;
start++;

Pour ce faire, nous utilisons le temp variable pour contenir le start personnage. Ensuite, nous écrasons le début caractère avec la fin personnage. À ce stade, nous écrasons la fin caractère avec le début caractère que nous avons stocké dans temp .

Lorsque nous avons terminé l'échange de caractères, nous décrémentons le fin pointeur et incrémentez le début aiguille. Cela nous permet d'inverser lentement chaque paire de caractères jusqu'à atteindre le milieu de la chaîne.

La déclaration de retour

Enfin, nous convertissons notre tableau de caractères en String, et nous le renvoyons :

return new String(characters);

À un niveau élevé, nous prenons une chaîne de la ligne de commande, l'inversons et la transmettons à l'utilisateur. C'est tout !

Comment exécuter la solution

Si nous cherchons à exécuter ce programme, la première chose à faire est peut-être de télécharger la solution depuis GitHub. Ensuite, nous devrons obtenir la dernière version de Java. À ce stade, tout ce que nous avons à faire est d'exécuter ce qui suit à partir de la ligne de commande :

javac ReverseString.java
java ReverseString "Hello, World!"

La première ligne compile le code tandis que la deuxième ligne exécute le binaire. Dans ce cas, nous essayons d'inverser "Hello, World !"

Alternativement, nous pouvons exécuter la solution Inverser une chaîne en Java à l'aide d'un compilateur Java en ligne. Copiez simplement la solution dans le volet de développement, ajoutez une chaîne aux arguments de la ligne de commande et appuyez sur Exécuter.

Exemples de programmes dans toutes les langues

Eh bien, c'est tout pour inverser une chaîne en Java ! Si vous avez aimé cet article, assurez-vous de lui donner une part. De plus, si vous souhaitez suggérer une langue pour un futur article, n'hésitez pas à la déposer ci-dessous dans les commentaires. La prochaine fois, nous verrons Inverser une chaîne dans Dart.

N'oubliez pas que vous pouvez toujours contribuer à ce projet via le référentiel GitHub !