Sous-chaîne en Java

Les actions les plus populaires sur String en Java sont la concaténation, l'obtention d'un caractère par index et l'obtention d'une sous-chaîne. Dans cet article, nous allons vous parler de la méthode de sous-chaîne Java.

Qu'est-ce que la sous-chaîne Java ?

La sous-chaîne Java en général est une séquence contiguë de caractères à l'intérieur de la chaîne. Il peut s'agir d'une partie de la chaîne ou de la chaîne entière également. Qu'est-ce qu'une sous-chaîne en Java ? Ce langage possède une méthode substring() , ou plutôt deux méthodes, grâce à la surcharge des méthodes Java. Vous pouvez les utiliser pour obtenir une sous-chaîne dans le programme Java. La première méthode de sous-chaîne Java est String substring(firstIndex) et la seconde est String substring (firstIndex, lastIndex) .

Comment utiliser la sous-chaîne en Java

La réponse est simple : utilisez simplement la sous-chaîne. La méthode Java substring() renvoie une partie de la chaîne. Il existe deux méthodes que vous pouvez utiliser pour cela :Tâches très populaires qui vous aident à comprendre

• Comment obtenir une sous-chaîne en Java
• Comment trouver toutes les sous-chaînes d'une chaîne donnée
• Comment trouver la plus longue sous-chaîne commune

Comment obtenir une sous-chaîne en Java (en particulier)

Ce premier exemple de sous-chaîne Java est assez simple. Vous avez une chaîne et vous devez y trouver une sous-chaîne "CodeGym". Vous savez déjà comment obtenir une sous-chaîne en Java. Voici donc la solution de ce problème particulier :

import java.io.IOException;

public class Main {

   public static void main(String[] args) throws IOException {

       String s1 = "the best Java Core course is CourseCodeGym.  End of story";
       String myTarget = "CodeGym";
       int index1 = s1.indexOf(myTarget);

       int index2 = index1 + myTarget.length();
       System.out.println(s1.substring(index1, index2));

   }
}

La sortie est : CodeGym Process terminé avec le code de sortie 0 Comment trouver toutes les sous-chaînes d'une chaîne donnée Ici, nous avons le moyen le plus simple de trouver toutes les sous-chaînes d'une chaîne donnée.

import java.io.IOException;
public class Main {
   public static void main(String[] args) throws IOException {
       String myTarget = "CodeGym";
       for (int i = 0; i < myTarget.length(); i++) {
           for (int j = i + 1; j <= myTarget.length(); j++) {
               System.out.println(myTarget.substring(i, j));
           }
       }
   }
}

La sortie est : C Co Cod Code CodeG CodeGy CodeGym o od ode odeG odeGy odeGym d de deG deGy deGym eG eGy eGym G Gy Gym y ym m Processus terminé avec le code de sortie 0 Comment trouver la plus longue sous-chaîne commune Le problème de la plus longue sous- chaîne commune est l'une des tâches les plus populaires en informatique. Vous pouvez le rencontrer lors de votre entretien avec un développeur junior avec une probabilité assez élevée. Quoi qu'il en soit, essayez de le résoudre, c'est un exercice très utile pour un programmeur débutant. Le problème de sous-chaîne commun le plus long consiste à trouver la chaîne la plus longue (ou quelques-unes d'entre elles) qui est une sous-chaîne (ou sont des sous-chaînes) de deux chaînes ou plus. Par exemple, vous avez deux chaînes

String first = "CodeGym"
String second = "SomeGym"

La sortie devrait être : eGym Donc, vous devez définir les chaînes "first" et "second". Affiche la plus longue sous-chaîne commune. Si deux ou plusieurs sous-chaînes ont la même valeur pour la plus longue sous-chaîne commune, imprimez l'une d'entre elles. Nous vous recommandons fortement d'essayer de résoudre ce problème par vous-même et seulement après cela, examinez le code ci-dessous.

public class SubStringTest {

   //  in this method we are looking for the Longest common substring of
   // first String with length = m  and the second String with length = n
   public static String longestCS(String first, String second, int m, int n) {
       // the maximal length
       int maxLength = 0;
       // the last index of the longest common substring
       int endIndex = m;

       // array stores the length of substring
       int[][] keeper = new int[m + 1][n + 1];

       for (int i = 1; i <= m; i++) {
           for (int j = 1; j <= n; j++) {
               // check if current characters of first and second strings match
               if (first.charAt(i - 1) == second.charAt(j - 1)) {
                   keeper[i][j] = keeper[i - 1][j - 1] + 1;

                   if (keeper[i][j] > maxLength) {
                       maxLength = keeper[i][j];
                       endIndex = i;
                   }
               }
           }
       }
       return first.substring(endIndex - maxLength, endIndex);
   }


   public static void main(String[] args) {
       String first = "CodeGym";
       String second = "SomeGym";
       int m = first.length(), n = second.length();
       System.out.println("The longest common substring = " + longestCS(first, second, m, n));
   }
}

La sortie est : La plus longue sous-chaîne commune = eGym

Comment fonctionne la sous-chaîne en Java

Dans JDK 7 et les versions plus récentes, substring() ne compte plus le nombre de caractères dans le tableau de caractères qu'il crée, comme il le faisait dans les versions antérieures à JDK 6 inclus, mais crée simplement un nouveau tableau en mémoire (heap) et s'y réfère . Voici un exemple:

String x = "CodeGymIsTheBest";
String y = x.substring (2,6);
String z = x.substring (0,3);

Ainsi, dans JDK 7 et versions ultérieures, les objets y et z créés à la suite de la méthode substring() appliquée à l'objet x feront référence à deux tableaux nouvellement créés (sur le tas) - {d, e, G, y} pour y et {C, o} pour z. Dans la version JDK 7 + de la sous-chaîne de méthode, ces deux nouvelles lignes (c'est-à-dire deux nouveaux tableaux de caractères) seront stockées en mémoire avec la chaîne d'origine myLongString ({C, o, d, e, G, y, m , i, s, t, h, e, b,e,s,t} sous la forme d'un tableau).

Version JDK 6 de la sous-chaîne

Même aujourd'hui, sur certains grands projets, vous pouvez rencontrer 6 fois la base de code héritée du JDK. Dans JDK 6, la méthode substring() fonctionne différemment. Comme vous le savez probablement, String est une classe immuable et pour obtenir la sous-chaîne, Java a utilisé cette immuabilité plus tôt dans JDK 6. L'objet de type String à l'intérieur est juste un tableau de caractères, ou plutôt, contient un tableau de caractères. A l'époque du JDK 6, deux autres variables y étaient stockées : le numéro du premier caractère du tableau de caractères et leur quantité. Ainsi, dans JDK 6, String avait trois champs de char value [] (tableau de caractères), int offset (index du premier caractère du tableau) et int count(le nombre de caractères dans le tableau). Lorsqu'une sous-chaîne est créée dans JDK 6, le tableau de caractères n'est pas copié dans le nouvel objet String . Au lieu de cela, les deux objets stockent une référence au même tableau de caractères. Cependant, le deuxième objet stocke deux autres variables, le premier symbole de sous-chaîne et le second concerne le nombre de symboles dans la sous-chaîne. La méthode JDK 6 a été remplacée en raison d'un problème de fuite de mémoire. Qu'est-ce que ça veut dire? Supposons que nous ayons une chaîne xet que nous créons quelques sous-chaînes en utilisant substring.

String x = "CodeGymIsTheBest";
String y = x.substring (2,6);
String z = x.substring (0,3);

Nous avons maintenant un objet x stocké dans une zone spéciale de la mémoire appelée le tas, et deux objets y et z faisant référence au même objet x . Seul x fait référence aux éléments du deuxième au sixième, et z fait référence aux éléments x de zéro au troisième. Que se passe-t-il si l'objet d'origine x a déjà été utilisé et laissé sans aucune référence ? Dans un programme, tous les autres objets fonctionnent uniquement avec y et z . Dans ce cas, le ramasse-miettes peut détruire l'objet x, tandis que la matrice mémoire reste, et elle est utilisée par y et z. La fuite de mémoire se produit. Ainsi, la méthode la plus récente, JDK 7 et versions ultérieures, est assez coûteuse en termes d'utilisation de la mémoire. Cependant, cela vous permet d'éviter la fuite de mémoire. De plus, la nouvelle méthode fonctionne plus rapidement, car elle n'a pas à calculer le nombre de caractères. Pour renforcer ce que vous avez appris, nous vous suggérons de regarder une leçon vidéo de notre cours Java