Exemple de classe de chaînes Java (avec vidéo)
Cet article parle de l'une des bibliothèques String les plus utilisées en Java qui ne fait rien de moins que de la magie. Il passe en revue certaines des méthodes Java String courantes disponibles avant Java 8. Ensuite, il spécifie certaines des méthodes String importantes introduites dans et après Java 8.
Vous pouvez également consulter ce tutoriel dans la vidéo suivante :
Table des matières
- 1. Présentation
- 2. Méthodes de base de Java String Class
- 2.1 Méthodes Java String Equal
- 2.2 Méthodes de cas de chaîne Java
- 2.3 Méthodes d'indexation des chaînes Java
- 2.4 Méthodes de sous-chaîne Java
- 2.5 Méthodes de remplacement de chaîne Java
- 2.6 Méthodes de comparaison de chaînes Java
- 2.7 Méthodes de fractionnement de chaînes Java
- 2.8 Java String Autres méthodes courantes
- 2.9 Méthodes de chaîne Java 8
- 2.10 Méthodes de chaîne Java 9
- 2.11 Méthodes de chaîne Java 11
- 2.12 Méthodes de chaîne Java 12
- 3. Autres caractéristiques des objets String
- 4. Plus d'articles
- 5. Télécharger le projet Eclipse
1. Présentation
Dans cet exemple, nous allons discuter des caractéristiques de base de Java String Class. String est probablement l'un des types les plus utilisés dans les programmes Java. C'est pourquoi Java fournit un certain nombre de méthodes d'API qui font de String manipulation facile et efficace, tout droit sorti de la boîte. Strings sont si importants que même dans les dernières versions de Java (y compris 7 et 8), plusieurs modifications ont été apportées à ses méthodes de classe et à sa représentation interne, l'améliorant encore plus en termes de performances et de sécurité.
2. Méthodes de base de Java String Class
Un String est simplement une séquence de caractères. En fait, un String L'objet est soutenu par un char déployer. Par conséquent, il ne se termine pas par null, comme en C/C++.
Voici comment vous pouvez créer un String
| 1 | String str= "Hello World" ; |
"Hello World" s'appelle un String littéral. Dans un programme Java, tout ce qui est entre deux guillemets doubles est un String littéral. Les littéraux sont implémentés en tant qu'instances de la classe String. Comme vous pouvez le voir, vous pouvez facilement initialiser un String Objet comme un type primitif, par exemple int i = 0; .
Il n'est pas nécessaire de faire :
| 1 | String str = new String( "Hello World" ); |
Il y a une différence entre ces deux méthodes d'initialisation, bien que le résultat soit le même :A String avec la valeur "Hello World". Mais plus à ce sujet dans un instant.
Pour l'instant, voici un simple main avec le String le plus important Méthodes API :
StringClassExample.java
| 001002003004005006007008009010011012013014015016017018019020021022023024025026027028029030031032033034035036037038039040041042043044045046047048049050051052053054055056057058059060061062063064065066067068069070071072073074075076077078079080081082083084085086087088089090091092093094095096097098099100101102103104105106 | package com.javacodegeeks.core.lang.string; public class StringClassExample { public static void main(String[]args){ //Initialization with literal String str1 = "Hello World" ; System.out.println( "str1:" +str1); //Initialization with char array char arr[] = { 'H' , 'e' , 'l' , 'l' , 'o' }; String str2 = new String(arr); System.out.println( "str2:" +str2); //Concatenation using + operator String str3 = "World" ; str3 = str2 + " " + str3; System.out.println( "str3:" +str3); //find out the length of a string System.out.println(str3.length()); //You can even apply that to literals, as with all String API methods //As we said. literals are implemented as String instances System.out.println( "Length: " + "abcdefg" .length()); //Substring from position 2 to position 10 String c = str1.substring( 2 , 10 ); System.out.println( "Substring :" +c); //Substring from position 1 to position 4 System.out.println( "Literal Substring :" + "abcdefghigklm" .substring( 1 , 4 )); // Get the charcter array of the string. char [] chars = c.toCharArray(); System.out.println( "Char array : [" +chars[ 0 ]+ "," +chars[ 1 ]+ "," +chars[ 2 ]+ "]" ); //find the first index of a char inside a string int i = str1.indexOf( 'W' ); System.out.println( "Index of 'W':" +i); //find the first index of a string inside another string after a certain position i = str1.indexOf( "orld" , 5 ); System.out.println( "Index of 'orld':" +i); //find the last index of a string inside another string i = str1.lastIndexOf( "l" ); System.out.println( "LAST Index of 'l':" +i); //find the last index of a string inside another string after a certain position // - like scanning the string backwards i = str1.lastIndexOf( "l" , 7 ); System.out.println( "LAST Index of 'l':" +i); //find a character in a certain position char cr = str1.charAt( 5 ); System.out.println( "Character at position 5:" +cr); //Lower case System.out.println( "ABCEFAFA" .toLowerCase()); //Upper case System.out.println( "abcasipasc" .toUpperCase()); //replace occurrences of a character str1 = str1.replace( 'o' , '0' ); System.out.println(str1); //Trim white spaces from the end and the beginning String str4 = " Java" ; System.out.println(str4); System.out.println(str4.trim()); //Split !!! String str5= "Java is great" ; String[] strArray = str5.split( " " ); System.out.println(strArray[ 0 ]+ "," +strArray[ 1 ]+ "," +strArray[ 2 ]); str5= "Java-is-great" ; strArray = str5.split( "-" ); System.out.println(strArray[ 0 ]+ "," +strArray[ 1 ]+ "," +strArray[ 2 ]); str5= "Java is great" ; strArray = str5.split( "/*" ); System.out.println(strArray[ 0 ]+ "," +strArray[ 1 ]+ "," +strArray[ 2 ]+ "," +strArray[ 3 ]+ "," +strArray[ 4 ]+ "," +strArray[ 5 ]+ "," +strArray[ 6 ]+ "," +strArray[ 7 ]+ "," +strArray[ 8 ]); //contains and equals System.out.println( "Contains :" + "qwerty" .contains( "ert" )); System.out.println ( "Equals :" +str5.equals( "java is great" )); System.out.println ( "Equals ignore case:" +str5.equalsIgnoreCase( "java is great" )); // Compare lexicographically two strings System.out.println ( "Compare:" +str5.compareTo( "abc" )); //comparison attempts String s1 = "abc" ; String s3 = new String( "abc" ); System.out.println(s1==s3); System.out.println(s1.equalsIgnoreCase(s3)); } } |
Voici la sortie du programme ci-dessus :
str1:Hello World str2:Hello str3:Hello World 11 Length: 7 Substring :llo Worl Literal Substring :bcd Char array : [l,l,o] Index of 'W':6 Index of 'orld':7 LAST Index of 'l':9 LAST Index of 'l':3 Character at position 5: abcefafa ABCASIPASC Hell0 W0rld Java Java Java,is,great Java,is,great ,J,a,v,a, ,i,s, Contains :true Equals :false Equals ignore case:true Compare:-23 false true
D'après le programme ci-dessus, il est clair que les concepteurs Java ont décidé de traiter les chaînes quelque peu différemment des autres objets. Par exemple, vous pouvez les initialiser comme une primitive, par exemple String a="abc" et vous pouvez concaténer deux chaînes en utilisant + opérateur, comme si vous ajoutiez deux ints (ressemble à une surcharge + opérateur en C++).
Le comparison attempts section du code peut sembler un peu floue, mais cela deviendra clair dans la section suivante. Ce que vous devriez en retenir maintenant, c'est que vous NE DEVRIEZ JAMAIS essayer de comparer le contenu de Strings en utilisant == opérateur. Vous ne comparez que l'égalité de référence, pas l'égalité de contenu. Vous DEVEZ utiliser equals ou equalsIgnoreCase .
2.1 Méthodes Java String Equal
La méthode suivante renvoie true si le contenu des deux chaînes est égal, sinon renvoie false. Il prend également en compte la casse du contenu.equals(String str)
public class EqualsExample{
public static void main(String[] args){
String s1 = "Java Code Geeks";
String s2 = "Java Code Geeks";
String s3 = "java code geeks";
System.out.println(s1.equals(s2)); //prints true
System.out.println(s1.equals(s3)); //prints false
}
}
La méthode suivante renvoie true si le contenu des deux chaînes est égal, sinon renvoie false. Il ne prend pas en compte la casse du contenu.equalsIgnoreCase(String str)
public class EqualsIgnoreCaseExample{
public static void main(String[] args){
String s1 = "Java Code Geeks";
String s2 = "Java Code Geeks";
String s3 = "java code geeks";
System.out.println(s1.equalsIgnoreCase(s2)); //prints true
System.out.println(s1.equalsIgnoreCase(s3)); //prints true
}
}
La méthode suivante prend comme paramètre un objet String ou StringBuffer et compare le contenu. Renvoie true si le contenu est le même en tenant compte de la casse également.contentEquals(StringBuffer str)
public class ContentEqualsExample{
public static void main(String[] args){
String s1 = "Java Code Geeks";
StringBuffer s2 = new StringBuffer("Java Code Geeks");
System.out.println(s1.contentEquals(s2)); //prints true
}
}
2.2 Méthodes de cas de chaîne Java
La méthode suivante convertit le contenu de la chaîne en minuscules.toLowerCase()
public class ToLowerCaseExample{
public static void main(String[] args){
String s1 = "JAVA CODE GEEKS";
System.out.println(s1.toLowerCase()); //prints java code geeks
}
}
La méthode suivante convertit le contenu de la chaîne en majuscule.toUpperCase()
public class ToUpperCaseExample{
public static void main(String[] args){
String s1 = "java code geeks";
System.out.println(s1.toUpperCase()); //prints JAVA CODE GEEKS
}
}
2.3 Méthodes d'indexation des chaînes Java
La méthode suivante renvoie l'index de la première occurrence du caractère ch. Renvoie -1 s'il n'y a pas d'occurrence.indexOf(char ch)
public class IndexOfCharExample{
public static void main(String[] args){
String s1 = "Java Code Geeks";
System.out.println(s1.indexOf('a')); //prints 1
System.out.println(s1.indexOf('z')); //prints -1
}
}
La méthode suivante renvoie l'index de la première occurrence de la sous-chaîne str. Renvoie -1 s'il n'y a pas d'occurrence.indexOf(String str)
public class IndexOfStringExample{
public static void main(String[] args){
String s1 = "Java Code Geeks";
System.out.println(s1.indexOf("Code")); //prints 5
System.out.println(s1.indexOf("Test")); //prints -1
}
}
La méthode suivante renvoie l'index de la première occurrence du caractère ch après fromIndex. Il commence la recherche après le fromIndex dans la chaîne. Renvoie -1 s'il n'y a pas d'occurrence après fromIndex.indexOf(char ch, int fromIndex)
public class IndexOfCharFromIndexExample{
public static void main(String[] args){
String s1 = "Java Code Geeks";
System.out.println(s1.indexOf('a',2)); //prints 3
System.out.println(s1.indexOf('a',5)); //prints -1
}
}
La méthode suivante renvoie l'index de la première occurrence de la sous-chaîne str après fromIndex. Il commence la recherche après le fromIndex dans la chaîne. Renvoie -1 s'il n'y a pas d'occurrence après fromIndex.indexOf(String str, int fromIndex)
public class IndexOfStringFromIndexExample{
public static void main(String[] args){
String s1 = "Java Code Java";
System.out.println(s1.indexOf("Java",4)); //prints 10
System.out.println(s1.indexOf("Code",10)); //prints -1
}
}
La méthode suivante renvoie l'index de la dernière occurrence du caractère ch. Renvoie -1 s'il n'y a pas d'occurrence.lastIndexOf(char ch)
public class LastIndexOfCharExample{
public static void main(String[] args){
String s1 = "Java Code Geeks";
System.out.println(s1.lastIndexOf('a')); //prints 3
System.out.println(s1.lastIndexOf('z')); //prints -1
}
}
La méthode suivante renvoie l'index de la dernière occurrence de la sous-chaîne str. Renvoie -1 s'il n'y a pas d'occurrence.lastIndexOf(String str)
public class LastIndexOfStringExample{
public static void main(String[] args){
String s1 = "Java Code ode";
System.out.println(s1.lastIndexOf("ode")); //prints 10
System.out.println(s1.indexOf("Test")); //prints -1
}
}
La méthode suivante renvoie l'index de la dernière occurrence du caractère ch en recherchant en arrière à partir de fromIndex. Renvoie -1 s'il n'y a pas d'occurrence après fromIndex.lastIndexOf(char ch, int fromIndex)
public class LastIndexOfCharFromIndexExample{
public static void main(String[] args){
String s1 = "Java Code Geeks";
System.out.println(s1.lastIndexOf('e',9)); //prints 8
System.out.println(s1.lastIndexOf('G',4)); //prints -1
}
}
La méthode suivante renvoie l'index de la dernière occurrence de la sous-chaîne str en recherchant en arrière à partir de fromIndex. Renvoie -1 s'il n'y a pas d'occurrence après fromIndex.lastIndexOf(String str, int fromIndex)
public class LastIndexOfStringFromIndexExample{
public static void main(String[] args){
String s1 = "Java Code Java";
System.out.println(s1.lastIndexOf("Java",13)); //prints 10
System.out.println(s1.lastIndexOf("Code",4)); //prints -1
}
}
2.4 Méthodes de sous-chaîne Java
La méthode suivante renvoie la sous-chaîne de la chaîne qui commence à partir de l'index beginIndex et s'étend jusqu'à endIndex-1. Le beginIndex est inclusif et endIndex est exclusif.substring(int beginIndex int endIndex)
public class SubstringExample1{
public static void main(String[] args){
String s1 = "Java Code Geeks";
String s2 = s1.substring(0,9);
System.out.println(s2); //prints Java Code
}
}
La méthode suivante renvoie la sous-chaîne de la chaîne qui commence à partir de l'index beginIndex et s'étend jusqu'à la fin de la chaîne.substring(int beginIndex)
public class SubstringExample2{
public static void main(String[] args){
String s1 = "Java Code Geeks";
String s2 = s1.substring(5);
System.out.println(s2); //prints Code Geeks
}
}
La méthode suivante se comporte exactement de la même manière que substring(int beginIndex, int endIndex). La seule différence est que subSequence renvoie un CharSequence.subSequence(int beginIndex, int endIndex)
public class SubSequenceExample{
public static void main(String[] args){
String s1 = "Java Code Geeks";
CharSequence s2 = s1.subSequence(0,4);
System.out.println(s2); //prints Java
}
}
Vous pouvez également consulter cet exemple Java de sous-chaîne pour plus de connaissances.
2.5 Méthodes de remplacement de chaîne Java
La méthode suivante remplace toutes les occurrences de oldChar par newChar dans la chaîne.replace(char oldChar, char newChar)
public class ReplaceExample1{
public static void main(String[] args){
String s1 = "Java Code Geeks";
String s2 = s1.replace('e','i');
System.out.println(s2); //prints Java Codi Giiks
}
}
La méthode suivante remplace toutes les occurrences de la chaîne cible par la chaîne de remplacement.replace(CharSequence target, CharSequence replacement)
public class ReplaceExample2{
public static void main(String[] args){
String s1 = "Java Code Geeks";
String s2 = s1.replace("Geeks","Experts");
System.out.println(s2); //prints Java Code Experts
}
}
La méthode suivante remplace toutes les occurrences de substring qui correspondent à l'expression régulière regex par le remplacement de chaîne.replaceAll(String regex, String replacement)
public class ReplaceAllExample{
public static void main(String[] args){
String s1 = "Java Code Geeks";
String s2 = s1.replaceAll("Geeks","Experts");
//The below line removes all white spaces
String s3 = s1.replaceAll("\\s", "");
System.out.println(s2); //prints Java Code Experts
System.out.println(s3); //prints JavaCodeGeeks
}
}
La méthode suivante remplace uniquement la première occurrence de la sous-chaîne qui correspond à l'expression régulière regex avec le remplacement de chaîne.replaceFirst(String regex, String replacement)
public class ReplaceFirstExample{
public static void main(String[] args){
String s1 = "Java Code Geeks helps to learn Java";
String s2 = s1.replaceFirst("Java","JAVA");
String s3 = s1.replaceFirst("[a]", "A");
System.out.println(s2); //prints JAVA Code Geeks helps to learn Java
System.out.println(s3); //prints JAva Code Geeks helps to learn Java
}
}
2.6 Méthodes de comparaison de chaînes Java
La méthode suivante compare deux chaînes de manière lexicographique, c'est-à-dire la valeur Unicode de chaque caractère dans les chaînes. Elle renvoie un nombre positif (différence de valeur de caractère) si la première chaîne est lexicographiquement supérieure à la deuxième chaîne, renvoie un nombre négatif si la première chaîne est lexicographiquement inférieure à la deuxième chaîne et renvoie 0 si deux chaînes sont lexicographiquement égales. Cette méthode est sensible à la casse.compareTo(String str)
public class CompareToExample1{
public static void main(String[] args){
String s1 = "Code";
String s2 = "Node";
String s3 = "Code";
String s4 = "code";
System.out.println(s2.compareTo(s1)); //prints 11 as 'N' is 11 characters ahead of 'C'
System.out.println(s1.compareTo(s3)); //prints 0
System.out.println(s1.compareTo(s4)); //prints -32 as 'C' is 32 characters behind 'c'
}
}
La méthode suivante compare deux chaînes de manière lexicographique, c'est-à-dire la valeur Unicode de chaque caractère dans les chaînes. Elle renvoie un nombre positif (différence de valeur de caractère) si la première chaîne est lexicographiquement supérieure à la deuxième chaîne, renvoie un nombre négatif si la première chaîne est lexicographiquement inférieure à la deuxième chaîne et renvoie 0 si deux chaînes sont lexicographiquement égales. Cette méthode n'est pas sensible à la casse.compareToIgnoreCase(String str)
public class CompareToExample2{
public static void main(String[] args){
String s1 = "Code";
String s2 = "code";
System.out.println(s2.compareToIgnoreCase(s1)); //prints 0
}
}
2.7 Méthodes de fractionnement de chaînes Java
La méthode suivante divise la chaîne sur les correspondances de l'expression régulière regex et renvoie un tableau String contenant tous les éléments après la division.split(String regex)
public class SplitExample1{
public static void main(String[] args){
String s1 = "Java Code Geeks";
String[] s2 = s1.split(" "); //Splits s1 on white spaces and stores the elements in array s2 as {"Java","Code","Geeks"}
System.out.println(s2.length); //prints 3
}
}
La méthode suivante divise la chaîne sur les correspondances de l'expression régulière regex et renvoie un tableau String contenant tous les éléments après la division. Le nombre d'éléments dans le tableau ne dépassera pas la limite du paramètre.split(String regex, int limit)
public class SplitExample2{
public static void main(String[] args){
String s1 = "Java Code Geeks";
String[] s2 = s1.split(" ",2); //Splits s1 on white spaces and stores only 2 elements in array s2 as {"Java","Code"}
System.out.println(s2.length); //prints 2
}
}
2.8 Java String Autres méthodes courantes
La méthode suivante renvoie la longueur de la chaîne.length()
public class LengthExample{
public static void main(String[] args){
String s1 = "Java Code Geeks";
System.out.println(s1.length()); //prints 15
}
}
La méthode suivante renvoie un tableau de caractères contenant tous les caractères de la chaîne.toCharArray()
public class ToCharArrayExample{
public static void main(String[] args){
String s1 = "Java Code Geeks";
char[] s2 = s1.toCharArray();
System.out.println("["+s2[0]+","+s2[1]+","+s2[2]+"]"); //prints [J,a,v]
}
}
La méthode suivante supprime les espaces blancs de fin et de tête de String.trim()
public class TrimExample{
public static void main(String[] args){
String s1 = " Java Code Geeks ";
System.out.println(s1.trim()); //prints Java Code Geeks
}
}
La méthode suivante renvoie le caractère présent à l'index spécifié.charAt(int index)
public class CharAtExample{
public static void main(String[] args){
String s1 = "Java Code Geeks";
char ch = s1.charAt(5);
System.out.println(ch); //prints C
}
}
La méthode suivante renvoie true si String contient la sous-chaîne représentée par sequence, sinon renvoie false.contains(CharSequence sequence)
public class ContainsExample{
public static void main(String[] args){
String s1 = "Java Code Geeks";
System.out.println(s1.contains("Code")); //prints true
System.out.println(s1.contains("Node")); //prints false
}
}
2.9 Méthodes de chaîne Java 8
La méthode suivante prend en entrée différentes chaînes au format var-args et les joint en les séparant par le délimiteur d'argument.join(CharSequence delimiter, CharSequence… elements)
public class JoinExample1{
public static void main(String[] args){
String joinedString = String.join("-","Java","Code","Geeks");
System.out.println(joinedString); //prints Java-Code-Geeks
}
}
La méthode suivante prend en entrée une liste de chaînes ou un tableau de chaînes et joint les éléments de la liste ou du tableau séparés par le délimiteur d'argument.join(CharSequence delimiter, Iterable elements)
public class JoinExample2{
public static void main(String[] args){
List strList = Arrays.asList("Java","Code","Geeks");
String joinedString = String.join("-",strList);
System.out.println(joinedString); //prints Java-Code-Geeks
}
}
2.10 Méthodes de chaîne Java 9
La méthode suivante convertit la chaîne en valeurs char et renvoie les valeurs char sous forme de flux de int.chars()
public class CharsExample{
public static void main(String[] args){
String str = "Java Code Geeks";
IntStream stream = str.chars();
stream.forEach(x -> System.out.printf("-%s", (char)x)); //prints -J-a-v-a- -C-o-d-e- -G-e-e-k-s
}
}
La méthode suivante convertit la chaîne en un flux de valeurs de points de code.codePoints()
public class CodePointsExample{
public static void main(String[] args){
String str = "Java Code Geeks";
IntStream stream = str.codePoints();
stream.forEach(x -> System.out.print(
new StringBuilder().appendCodePoint(Character.toChars(x)[0]).toString())); //prints Java Code Geeks
}
}
2.11 Méthodes de chaîne Java 11
La méthode suivante supprime les espaces blancs de fin et de tête de String.strip()
public class StripExample{
public static void main(String[] args){
String str = " Java Code Geeks ";
System.out.println(str.strip()); //prints Java Code Geeks
}
}
Sortie Java Code Geeksstrip() est différent de la méthode trim() déjà existante dans la mesure où trim() supprime uniquement les espaces dont le point de code est inférieur ou égal à 'U+0020' (le caractère d'espace) alors que strip() supprime tous les espaces.
La méthode suivante supprime tous les espaces de début de la chaîne.stripLeading()
public class StripLeadingExample{
public static void main(String[] args){
String str = " Java Code Geeks";
System.out.println(str.stripLeading()); //prints Java Code Geeks
}
}
Sortie Java Code Geeks
La méthode suivante supprime tous les espaces de fin de la chaîne.stripTrailing()
public class StripTrailingExample{
public static void main(String[] args){
String str = "Java Code Geeks ";
System.out.println(str.stripTrailing()); //prints Java Code Geeks
}
}
Sortie Java Code Geeks
La méthode suivante renvoie true si la chaîne est vide, sinon false.isBlank()
public class IsBlankExample{
public static void main(String[] args){
String str = " ";
System.out.println(str.isBlank()); //prints true
}
}
Sortie trueisBlank() est différent de isEmpty() dans la mesure où isBlank() détecte également les espaces blancs U+2005.
La méthode suivante divise une chaîne en flux de lignes distinctes et séparées par des terminaisons de ligne qui peuvent être "\n", "\r" et "\r\n".lines()
public class LinesExample{
public static void main(String[] args){
String str = "Java Code Geeks hosts a lot of examples in Java.\nThis is an example of lines() method.";
str.lines().forEach(System.out::println);
}
}
Sortie Java Code Geeks hosts a lot of examples in Java. This is an example of lines() method.
La méthode suivante concatène la chaîne avec elle-même "n" nombre de fois. « n » ne peut pas être négatif. Si 'n' vaut 0, il renverra une chaîne vide.repeat(int n)
public class RepeatExample{
public static void main(String[] args){
String str = "Java Code Geeks";
System.out.println(str.repeat(2)); //prints Java Code GeeksJava Code Geeks
System.out.println(str.repeat(0)); //prints an empty String
}
}
Sortie Java Code GeeksJava Code Geeks
2.12 Méthodes de chaîne Java 12
La méthode suivante indente chaque ligne de la chaîne avec un nombre « n » d'espaces blancs. La méthode divise d'abord la chaîne en lignes séparées partout où elle trouve \n, puis insère un nombre « n » d'espaces blancs avant chaque ligne. Si n est supérieur à 0, il ajoute n espaces blancs avant chaque ligne. Si n est inférieur à 0, il supprime n espaces blancs ou tous les espaces blancs si n est supérieur au nombre d'espaces blancs. Si n est égal à 0 alors il reste inchangé.indent(int n)
public class IndentExample{
public static void main(String[] args){
String str = "Java Code Geeks.\nLearn Java";
String str1 = " Java Code Geeks.\n Learn Java";
String indentStr = str.indent(5);
String indentStr1 = str1.indent(-3);
System.out.println(str);
System.out.println(indentStr);
System.out.println(str1);
System.out.println(indentStr1);
}
}
Sortie Java Code Geeks. Learn Java Java Code Geeks. Learn Java Java Code Geeks. Learn Java Java Code Geeks. Learn Java
La méthode suivante exécute la fonction f en prenant la chaîne en entrée et renvoie la sortie de la fonction.transform(Function f)
public class TransformExample{
public static void main(String[] args){
String str = "Java Code Geeks";
var output = str.transform(input -> input.concat(" Learn Java")).transform(String::toUpperCase);
System.out.println(output.toString()); //prints JAVA CODE GEEKS LEARN JAVA
}
}
Sortie JAVA CODE GEEKS LEARN JAVA
3. Autres caractéristiques des objets String
String les objets sont immuables. Cela signifie qu'une fois qu'un String est créé, son contenu ne peut pas être modifié. Dans l'exemple ci-dessus, chaque fois que nous essayons de modifier son contenu, par exemple lors de la concaténation, un nouveau String objet est créé représentant le résultat. De plus, la classe String est finale, vous ne pouvez donc pas remplacer son comportement.
L'immuabilité a été principalement choisie pour des raisons de sécurité et de performances. Cela signifie également que deux threads différents peuvent partager la même chaîne et la manipuler comme ils le souhaitent, sans avoir à synchroniser quoi que ce soit, car chaque fois qu'ils modifient la chaîne d'origine, un nouveau est créé, tandis que l'ancien reste intact.
Voyons maintenant ceci :
| 1234567 | String s1 = "abc" ; String s2= "abc" ; String s3 = new String( "abc" ); System.out.println(s1==s2); System.out.println(s1==s3); |
Cela affiche :
true false
Les littéraux sont stockés dans un endroit spécial de la mémoire, appelé String pool , bien sûr sous la forme String Objets. Dans ce pool, un String l'objet avec la valeur "abc" n'est créé et stocké qu'une seule fois. Tout autre String qui obtient la valeur "abc" (statiquement - codé en dur) référencera le même String objet. Ainsi, chaque fois que vous créez un String en utilisant un littéral, le système recherchera ce pool et vérifiera si la valeur du littéral existe dans un objet du pool. Si c'est le cas, il renvoie la référence à cet objet correspondant, sinon il crée un nouvel objet et le stocke dans le pool. Donc, String les références, initialisées avec les mêmes littéraux, pointeront vers le même String objet. Cette technique a été utilisée pour économiser de la mémoire précieuse, car elle partage autant de données communes que possible.
Maintenant, vous pouvez également voir une autre raison pour laquelle les chaînes sont immuables. Imaginez que le thread A crée une chaîne locale "abc" puis un deuxième thread B crée sa propre chaîne locale "abc". Ces deux threads partageront le même objet String… Si String était modifiable, alors si A modifiait la chaîne, le changement affecterait le thread B, mais d'une manière dénuée de sens (catastrophique).
Lors de la création d'un String en utilisant new , vous créez explicitement un tout nouvel objet dans le tas. C'est également le cas pour String non codé en dur initialisation, par exemple, si vous lisez l'entrée Strings d'une source. Ces String Les objets ne seront pas stockés dans le pool. Imaginez que vous créez une application qui doit contenir les adresses des utilisateurs vivant en Grèce. Il y a quatre millions de personnes vivant à Athènes, alors considérez le gaspillage massif d'espace si vous stockez quatre millions d'objets String avec la valeur "Athènes". Afin de mutualiser ces Strings non codés en dur , il existe une méthode API appelée intern , et peut être utilisé comme ceci :
| 01020304050607080910 | String s1 = "abc" ; String s2= "abc" ; String s3 = new String( "abc" ); System.out.println(s1==s2); System.out.println(s1==s3); s3 = s3.intern(); System.out.println(s1==s3); |
Cela va maintenant afficher :
true false true
Lors de l'appel d'un stagiaire, le système suit la même procédure que si nous faisions s3 = "abc" , mais sans utiliser de littéraux.
Mais fais attention. Avant Java 7, ce pool était situé dans un endroit spécial du Java Heap, appelé PermGen. PermGen a une taille fixe et ne peut contenir qu'un nombre limité de littéraux de chaîne. Ainsi, l'internat doit être utilisé avec facilité. À partir de Java 7, le pool sera stocké dans le tas normal, comme tout autre objet (ce qui les rend éligibles à la récupération de place), sous la forme d'un hashmap et vous pouvez ajuster sa taille à l'aide de -XX:StringTableSize option. Vous pouvez créer votre propre pool de chaînes d'ailleurs, mais ne vous embêtez pas.
Ce n'est qu'un des aspects que les créateurs Java ont changé dans la classe String. Des modifications encore plus radicales ont été apportées, y compris la représentation interne de chaîne (elle a maintenant deux champs moins statiques).
4. Plus d'articles
- Exemple Java de chaîne à entier
- Convertir un entier en chaîne Exemple Java
- Exemple de comparaison de chaîne avec Java
