Comprendre la sous-chaîne en Java : un guide de base

Dans cet article, nous vous aiderons à comprendre les sous-chaînes en Java. Nous vous donnerons non seulement une explication théorique, mais également des exemples de code réels pour vous aider à visualiser. Nous allons vous apprendre à créer des sous-chaînes et vous aider à trouver des sous-chaînes à l’intérieur d’une chaîne.

Mais avant de les apprendre, nous devons avoir les bases des sous-chaînes.

Que sont les chaînes et les sous-chaînes ?

Dans le contexte de Java, une chaîne représente une séquence de caractères. Chaque chaîne en Java est un objet. Une chaîne en Java peut contenir des caractères, des symboles et même des espaces. D’autre part, une sous-chaîne en Java est une partie ou un sous-ensemble d’une chaîne Java.

Par exemple, «Geek» est une sous-chaîne de «GeekFlare». Les sous-chaînes vous aident à obtenir une partie spécifique d’une chaîne.

Si vous avez le nom «John Doe» et que vous ne voulez que le prénom «John», vous pouvez facilement l’obtenir avec des sous-chaînes. De plus, étant donné que vous avez une liste de noms «John, Jack, Jolly» et que vous voulez savoir si «John» y figure, vous pouvez également le faire avec des sous-chaînes. Ce ne sont que de simples exemples. Nous pouvons utiliser des sous-chaînes dans diverses opérations une fois que nous les comprenons.

Comme nous connaissons maintenant le concept de sous-chaînes en Java, apprenons maintenant à créer et à utiliser des sous-chaînes en Java.

#1. Utilisation de la méthode ‘substring()’

La méthode ‘substring()’ nous permet de créer très facilement des sous-chaînes. Il prend jusqu’à deux paramètres en entrée – startIndex ou les deux startIndex et endIndex et nous renvoie la sous-chaîne que nous voulons.

Selon le nombre de paramètres, nous pouvons l’utiliser de deux manières. Maintenant, apprenons à les connaître en détail.

sous-chaîne(int startIndex)

Pour commencer, nous pouvons utiliser la méthode sous la forme ‘substring(startIndex)’. Ici, cette méthode prend une valeur entière en entrée, où l’entrée est la position de départ de la sous-chaîne. Il renvoie une chaîne à partir de l’index de départ fourni jusqu’à la fin de la chaîne d’origine.

A titre d’exemple, regardons le code suivant :

public class Substrings{    
    public static void main(String args[]){    
    String str="GeekFlare";    
    System.out.println("Given String: " + str);  
    System.out.println("Substring: " +str.substring(4)); //index of strings start from 0
    }  
   }

SORTIR:

Given String: GeekFlare
Substring: Flare

À partir de la sortie, nous voyons que la chaîne d’entrée est «GeekFlare», et la valeur de retour est la sous-chaîne «Flare». Il crée une sous-chaîne à partir de l’index donné (4), c’est-à-dire de la position 5 à la fin de la chaîne.

sous-chaîne(int index de début, int index de fin)

C’est une autre façon d’utiliser la méthode substring de la classe String. Nous pouvons passer deux entiers à la méthode de sous-chaîne. Un index de début et un index de fin. Pour l’utiliser, nous devons utiliser la méthode au format ‘substring(startIndex,endIndex)’.

Pour mieux comprendre, regardons un exemple de code :

public class Substrings{    
    public static void main(String args[]){    
    String str="GeekFlareFans";    
    System.out.println("Given String: " + str);  
    System.out.println("Substring: " +str.substring(4,9));  //You get a substring starting from index no. 4 to index 8.

    }  
   }

SORTIR:

Given String: GeekFlareFans
Substring: Flare

Comme nous pouvons le voir, étant donné la chaîne «GeekFlareFans», il génère la sous-chaîne «Flare». Nous avons donné l’index de début de 4 et l’index de fin de 9. Il commence à partir de l’élément avec un index de 4 et se termine avant 9. Nous devons noter qu’il n’imprime pas l’élément avec l’index de fin. Cela nous donne une sous-chaîne qui inclut tous les éléments jusqu’à l’index de fin mais exclut l’élément avec l’index de fin.

#2. Utilisation de la méthode ‘split()’

Le ‘split()’ est une autre méthode de la classe String en Java qui nous aide à créer une sous-chaîne. Il est utile lorsque plusieurs éléments d’information sont stockés dans une chaîne avec un caractère de séparation commun.

La syntaxe mentionne le terme «regex» qui peut vous sembler un peu intimidant, alors comprenons ce qu’est regex avant de continuer. Regex est le terme court pour «Expressions régulières». Une expression régulière est une séquence de caractères qui décrit un modèle à l’intérieur d’une chaîne ou d’un texte. Dans le contexte de la méthode split, la regex est notre séparateur.

La méthode ‘split()’ peut accepter jusqu’à deux variables en entrée, il s’agit d’une chaîne regex et d’un entier limite. La regex est le séparateur qui, lorsqu’il est trouvé, divise la chaîne d’origine en 2 parties – la partie avant la regex et la partie après la regex.

Par exemple, supposons que vous essayez de diviser la chaîne «abcdef» avec «bcd» comme regex. Nous obtiendrions les sous-chaînes «a» et «ef» comme résultat.

La méthode renvoie un tableau avec les chaînes séparées. Nous pouvons soit spécifier uniquement la regex, soit à la fois la regex et la limite. Apprenons à connaître les multiples façons d’appeler cette méthode une par une.

split (chaîne regex)

La première méthode ne reçoit que la chaîne regex au format ‘split(regex)’. Il n’a pas de variable limite ; renvoie donc toutes les sous-chaînes séparées dans un tableau.

Comprenons bien avec un peu de code:

public class Substrings{    
    public static void main(String args[]){    
    String str="Geek%Flare";
    String[] substrings=str.split("%");
    System.out.println("Given String: " + str);
    System.out.println("First Substring: " + substrings[0]);
    System.out.println("Second Substring: " + substrings[1]);
     
    }  
}

SORTIR:

Given String: Geek%Flare
First Substring: Geek
Second Substring: Flare

Comme nous l’observons à partir du code, la chaîne donnée a un séparateur regex «%». Il ne doit pas nécessairement s’agir d’un seul caractère, il peut s’agir de n’importe quelle chaîne avec n’importe quel nombre de caractères. La méthode ‘split()’ ignore cette regex et nous donne toutes les chaînes qui ont été séparées par cette regex. Les sous-chaînes sont stockées dans un tableau.

Dans le code, la chaîne donnée est «Geek%Flare». Donc, nous obtenons un tableau avec deux éléments, qui sont «Geek» et «Flare». Nous y avons ensuite accédé avec leurs indices respectifs, qui sont respectivement 0,1, et nous avons imprimé «Geek» et «Flare» sur la console.

Ici, nous devons également noter que si aucun paramètre n’est passé à la méthode, elle générera simplement une erreur. Mais si nous donnons une chaîne vide («») en tant que regex, nous obtiendrons chaque caractère individuel en tant que sous-chaîne. Regardons l’exemple pour visualiser.

import java.util.Arrays;

public class Substrings{    
    public static void main(String args[]){    
    String str="Geek%Flare";
    String[] substrings=str.split("");
    System.out.println(Arrays.toString(substrings));
     
    }  
}

SORTIR:

[G, e, e, k, %, F, l, a, r, e]

D’après l’exemple, il est évident que le paramètre regex est une chaîne vide, il renvoie tous les caractères sous forme de sous-chaînes distinctes, et nous pouvons clairement le voir en imprimant le tableau de sortie de la méthode ‘split ()’.

split(String regex,int limite)

Avec la deuxième variante de cette méthode, nous obtenons plus de contrôle sur la sortie, et nous pouvons encore affiner la sortie de la méthode ‘split()’. Ici, la méthode ‘split()’ prend deux variables en entrée. Dans ce cas, avec la regex, nous donnons également un paramètre limit dans le format spécifié de ‘split(regex, limit)’.

La ‘limite’ est le nombre de chaînes résultantes qui sont sorties. Selon la valeur de la limite, il peut y avoir trois possibilités :

Cas 1 : Si limite>0, le tableau résultant contiendrait la sortie, mais il appliquerait au maximum les fractionnements (limite-1). Ici, le tableau résultant ne contiendrait pas plus d’éléments que la limite spécifiée, et toute la chaîne restante qui n’est pas divisée serait stockée telle quelle. Facilitons la compréhension avec du code.

import java.util.Arrays;

public class Substrings{    
    public static void main(String args[]){    
    String str="Geek%Flare%is%the%best";
    String[] substrings=str.split("%",2);
    System.out.println(Arrays.toString(substrings));
     
    }  
}

SORTIR:

[Geek, Flare%is%the%best]

Voyez dans la sortie comment il n’y a que deux éléments dans le tableau de résultats qui est le nombre donné dans le paramètre limit. Notez également que le fractionnement n’est appliqué qu’une seule fois, donc (limite-1) fois.

Cependant, si l’expression régulière est là deux fois de suite («%%»), elle aurait des sous-chaînes vides. Regardez ce bout de code pour mieux le comprendre.

import java.util.Arrays;

public class Substrings{    
    public static void main(String args[]){    
    String str="Geek%Flare%is%%the%best%%%";
    String[] substrings=str.split("%",5);
    System.out.println(Arrays.toString(substrings));
     
    }  
}

SORTIR:

[Geek, Flare, is, , the%best%%%]

Fondamentalement, si «%» est suivi d’un autre «%» ou de la fin de la chaîne, il se transforme en une sous-chaîne vide.

Cas 2 : Si limite<0l’action de fractionnement serait appliquée autant de fois que possible sans limite de taille de tableau, mais le tableau contiendrait des sous-chaînes vides si la regex est présente deux fois de suite («%%»).

import java.util.Arrays;

public class Substrings{    
    public static void main(String args[]){    
    String str="Geek%Flare%is%%the%best%%%";
    String[] substrings=str.split("%",-1);
    System.out.println(Arrays.toString(substrings));
     
    }  
}

SORTIR:

[Geek, Flare, is, , the, best, , , ]

D’après la sortie, il ressort que la division est appliquée autant de fois que possible, et qu’il existe également des sous-chaînes vides.

Cas 3 : Si limite=0, l’action de division serait également appliquée autant de fois que possible, mais ici toutes les sous-chaînes vides à la fin de la chaîne seraient supprimées du tableau.

import java.util.Arrays;

public class Substrings{    
    public static void main(String args[]){    
    String str="Geek%Flare%is%%the%best%%%";
    String[] substrings=str.split("%",0);
    System.out.println(Arrays.toString(substrings));
     
    }  
}

SORTIR:

[Geek, Flare, is, , the, best]

Nous pouvons voir que la sortie est assez similaire entre quand limit=-1 et quand limit=0, mais il n’y a pas de sous-chaînes vides à la fin. En d’autres termes, les sous-chaînes vides à la fin du tableau de sous-chaînes sont ignorées.

Notez également que si l’expression régulière n’est pas présente dans la chaîne, elle renvoie la chaîne d’origine entière comme résultat.

Rechercher si une chaîne contient une sous-chaîne

En plus de créer des sous-chaînes à partir de chaînes existantes, nous pouvons également spécifier une sous-chaîne et savoir si cette sous-chaîne existe dans une chaîne. C’est un moyen simple et rapide d’interroger une sous-chaîne, ce qui est utile dans de nombreux cas d’utilisation. Mais comment fait-on ? Diverses méthodes peuvent nous aider à y parvenir. Examinons-les un par un.

Utilisation de la méthode ‘contains()’ :

On peut très facilement trouver l’existence d’une sous-chaîne avec la méthode ‘contains()’. Cette méthode de la classe String prend une chaîne en entrée, qui est notre sous-chaîne, et renvoie une valeur booléenne vérifiant si la sous-chaîne est à l’intérieur de la chaîne ou non. Cette méthode peut être utilisée dans des blocs if-else, des opérateurs unaires et divers autres endroits pour implémenter une logique complexe.

Apprenons à connaître un peu plus cette méthode.

public class Substrings{    
    public static void main(String args[]){    
    String str="GeekFlare";    
    System.out.println("Does it contain Flare? \n"+ str.contains("Flare"));  
    }  
}

SORTIR:

Does it contain Flare? 
true

Le code vérifie la chaîne «GeekFlare» pour le mot «Flare», et en le trouvant avec succès, il renvoie un booléen «true», confirmant ainsi l’existence de la sous-chaîne.

public class Substrings{    
    public static void main(String args[]){    
    String str="GeekFlare";    
    System.out.println("Does it contain Flare? \n"+ str.contains("Flare1"));  
    }  
}

SORTIR:

Does it contain Flare? 
false

D’après l’exemple, nous comprenons que si la sous-chaîne n’est pas à l’intérieur de la chaîne, la méthode renverra false pour signifier sa non-existence. Nous pouvons donc être facilement sûrs que la sous-chaîne existe.

Recherche de la position d’une sous-chaîne

#1. Utilisation de ‘indexOf()’ :

La méthode ‘indexOf()’ peut être utilisée pour trouver l’existence d’une sous-chaîne ainsi que pour trouver son index. La méthode prend en entrée une chaîne ou un caractère et nous donne la position de sa première occurrence. Mais il ne peut nous donner que l’indice de la première occurrence et ne peut pas confirmer si d’autres occurrences existent. Autre chose à noter ici, si la sous-chaîne n’existe pas, la méthode renvoie -1.

Alors explorons un peu plus cette méthode.

public class Substrings{    
    public static void main(String args[]){    
    String str="GeekFlareGeekFlare";    
    System.out.println("Index of Flare: "+ str.indexOf("Flare"));  
    }  
}

SORTIR:

Index of Flare: 4

Ici, dans l’exemple, la première occurrence de la sous-chaîne «Flare» commence à partir de l’index 4 dans la chaîne «GeekFlareGeekFlare». Ainsi, comme prévu, la fonction a renvoyé l’index.

#2. Utilisation de ‘lastIndexOf()’ :

‘lastIndexOf()’ est très similaire à ‘indexOf()’. Ces deux méthodes prennent en entrée la sous-chaîne et renvoient l’index de sa position. Il a même la même valeur de retour lorsqu’il ne trouve pas la sous-chaîne dans la chaîne spécifiée. Ces deux méthodes renvoient -1 pour une recherche infructueuse.

Mais alors que ‘indexOf()’ renvoie l’index de la première occurrence de la sous-chaîne, ‘lastIndexOf()’ renvoie la dernière occurrence.

Voyons-le en action à travers le code :

public class Substrings{    
    public static void main(String args[]){    
    String str="GeekFlareGeekFlare";    
    System.out.println("Last index of Flare: "+ str.lastIndexOf("Flare"));  
    }  
}

SORTIR:

Last index of Flare:13

En observant cette sortie, nous comprenons que la méthode ‘lastIndexOf()’ se comporte comme prévu et nous obtenons l’index de la dernière occurrence de la sous-chaîne «Flare» dans la chaîne «GeekFlareGeekFlare».

FAQ

Conclusion

Dans cet article, nous avons discuté de diverses méthodes et éléments essentiels pour démarrer avec les sous-chaînes. Nous avons discuté de la création d’une sous-chaîne et de la vérification de l’existence d’une sous-chaîne dans une chaîne. Cela vous permettra de mieux comprendre comment travailler avec les sous-chaînes. Suivez les exemples et entraînez-vous davantage pour bien comprendre les sous-chaînes.

Ensuite, vous pouvez consulter notre liste de questions d’entretien Java.