Chaîne Java

Tutoriels

Java

La classe Java String est l’une des classes les plus largement utilisées. La classe Java String est définie dans le package java.lang.

Java String

Essentiellement, une chaîne de caractères est une séquence de caractères mais ce n’est pas un type primitif.
Lorsque nous créons une chaîne de caractères en Java, cela crée en réalité un objet de type String.
String est un objet immuable, ce qui signifie qu’il ne peut pas être modifié une fois créé.
String est la seule classe où la surcharge des opérateurs est prise en charge en Java. Nous pouvons concaténer deux chaînes de caractères en utilisant l’opérateur +. Par exemple, "a"+"b"="ab".
Java fournit deux classes utiles pour la manipulation des chaînes de caractères – StringBuffer et StringBuilder.

Allons-y et apprenons-en plus sur la classe Java String.

Différentes façons de créer une chaîne de caractères

Il existe de nombreuses façons de créer un objet de chaîne de caractères en Java, certaines des plus populaires sont les suivantes.

Utilisation de littéraux de chaîne

C’est la manière la plus courante de créer une chaîne. Dans ce cas, un littéral de chaîne est encadré par des guillemets doubles.
```
String str = "abc"; 
```
Lorsque nous créons une chaîne en utilisant des guillemets doubles, la JVM recherche dans le pool de chaînes pour voir si une autre chaîne est stockée avec la même valeur. Si elle est trouvée, elle renvoie simplement la référence à cet objet String, sinon elle crée un nouvel objet String avec la valeur donnée et le stocke dans le pool de chaînes.
Utilisation du nouveau mot-clé

Nous pouvons créer un objet String en utilisant l’opérateur new, tout comme n’importe quelle classe Java normale. Il existe plusieurs constructeurs disponibles dans la classe String pour obtenir une chaîne à partir d’un tableau de caractères, d’un tableau d’octets, d’un StringBuffer et d’un StringBuilder.
```
String str  =  new String("abc");
char[] a = {'a', 'b', 'c'};
String str2  =  new String(a);
```

Comparaison de chaînes en Java

La classe String fournit les méthodes equals() et equalsIgnoreCase() pour comparer deux chaînes. Ces méthodes comparent la valeur de la chaîne pour vérifier si deux chaînes sont égales ou non. Elles renvoient true si les deux chaînes sont égales et false sinon.

package com.journaldev.string.examples;

/**
 * Java String Example
 * 
 * @author pankaj
 *
 */
public class StringEqualExample {

	public static void main(String[] args) {
		// création de deux objets de chaîne
		String s1 = "abc";
		String s2 = "abc";
		String s3 = "def";
		String s4 = "ABC";
		
		System.out.println(s1.equals(s2));//true
		System.out.println(s2.equals(s3));//false
		
		System.out.println(s1.equals(s4));//false;
		System.out.println(s1.equalsIgnoreCase(s4));//true
	}

}

La sortie du programme ci-dessus est :

true
false
false
true

La classe String implémente l’interface Comparable, qui fournit les méthodes compareTo() et compareToIgnoreCase(), permettant de comparer deux chaînes lexicographiquement. Les deux chaînes sont converties en valeur Unicode pour la comparaison, et elles renvoient une valeur entière pouvant être supérieure, inférieure ou égale à zéro. Si les chaînes sont égales, elle renvoie zéro, sinon elle renvoie une valeur soit supérieure, soit inférieure à zéro.

package com.journaldev.examples;

/**
 * Java String compareTo Example
 * 
 * @author pankaj
 *
 */
public class StringCompareToExample {

	public static void main(String[] args) {
		
		String a1 = "abc";
		String a2 = "abc";
		String a3 = "def";
		String a4 = "ABC";
		
		System.out.println(a1.compareTo(a2));//0
		System.out.println(a2.compareTo(a3));//less than 0
		System.out.println(a1.compareTo(a4));//greater than 0
		System.out.println(a1.compareToIgnoreCase(a4));//0
	}

}

La sortie du programme ci-dessus est :

Veuillez consulter en détail à Exemple de compareTo de String.

Méthodes de chaînes Java

Jetons un coup d’œil à certaines des méthodes populaires de la classe String avec un programme exemple.

split()

La méthode split() de Java String est utilisée pour diviser la chaîne en utilisant l’expression donnée. Il existe deux variantes de la méthode split().

split(String regex): Cette méthode divise la chaîne en utilisant l’expression regex donnée et renvoie un tableau de chaînes.
split(String regex, int limit): Cette méthode divise la chaîne en utilisant l’expression regex donnée et renvoie un tableau de chaînes, mais l’élément du tableau est limité par la limite spécifiée. Si la limite spécifiée est 2, alors la méthode renvoie un tableau de taille 2.

package com.journaldev.examples;

/**
 * Exemple de division de chaîne Java String
 * 
 * @author pankaj
 *
 */
public class StringSplitExample {

	public static void main(String[] args) {
		
		String s = "a/b/c/d";
		String[] a1 = s.split("/");
		System.out.println("diviser la chaîne en utilisant uniquement regex:");
		for (String string : a1) {
			System.out.println(string);
		}
		System.out.println("diviser la chaîne en utilisant regex avec une limite:");
		String[] a2 = s.split("/", 2);
		for (String string : a2) {
			System.out.println(string);
		}
	}

}

La sortie du programme ci-dessus est:

diviser la chaîne en utilisant uniquement regex:
a
b
c
d
diviser la chaîne en utilisant regex avec une limite:
a
b/c/d

contains(CharSequence s)

Les méthodes Java String contains() vérifient si la chaîne contient une séquence de caractères spécifiée ou non. Cette méthode renvoie true si la chaîne contient une séquence de caractères spécifiée, sinon elle renvoie false.

package com.journaldev.examples;

/**
 * Exemple de contains() de chaîne Java
 * 
 * @author pankaj
 *
 */
public class StringContainsExample {

	public static void main(String[] args) {
		String s = "Hello World";
		
		System.out.println(s.contains("W"));//true
		System.out.println(s.contains("X"));//false
	}

}

La sortie du programme ci-dessus est:

true
false

longueur()

La méthode length() de la classe Java String renvoie la longueur de la chaîne.

package com.journaldev.examples;

/**
 * Longueur de la chaîne Java
 * 
 * @author pankaj
 *
 */
public class StringLengthExample {

	public static void main(String[] args) {
		
		String s1 = "abc";
		String s2 = "abcdef";
		String s3 = "abcdefghi";
		
		System.out.println(s1.length());//3
		System.out.println(s2.length());//6
		System.out.println(s3.length());//9

	}

}

remplacer()

La méthode replace() de Java String est utilisée pour remplacer une partie spécifique d’une chaîne par une autre chaîne. Il existe quatre variantes de la méthode replace().

replace(char oldChar, char newChar): Cette méthode remplace toutes les occurrences de oldChar par newChar dans la chaîne.
replace(CharSequence target, CharSequence replacement): Cette méthode remplace chaque littéral cible par le littéral de remplacement dans la chaîne.
replaceAll(String regex, String replacement): Cette méthode remplace toutes les occurrences des sous-chaînes qui correspondent à l’expression régulière spécifiée par le remplacement spécifié dans la chaîne.
replaceFirst(String regex, String replacement): Cette méthode remplace la première occurrence de la sous-chaîne qui correspond à l’expression régulière spécifiée par le remplacement spécifié dans la chaîne.

package com.journaldev.examples;

/**
 * Remplacement de chaîne Java
 * 
 * @author pankaj
 *
 */
public class StringReplaceExample {

	public static void main(String[] args) {
		
		//replace(char oldChar,  char newChar)
		String s = "Bonjour le monde";
		s = s.replace('l', 'm');
		System.out.println("Après le remplacement de l par m :");
		System.out.println(s);
		
		//replaceAll(String regex, String replacement)
		String s1 = "Bonjour journaldev, Bonjour pankaj";
		s1 = s1.replaceAll("Bonjour", "Salut");
		System.out.println("Après le remplacement :");
		System.out.println(s1);
		
		//replaceFirst(String regex, String replacement) 
		String s2 = "Bonjour les gars, Bonjour le monde";
		s2 = s2.replaceFirst("Bonjour", "Salut");
		System.out.println("Après le remplacement :");
		System.out.println(s2);

	}

}

La sortie du programme ci-dessus est :

Après le remplacement de l par m :
Bommour Wormd
Après le remplacement :
Salut journaldev, Salut pankaj
Après le remplacement :
Salut les gars, Bonjour le monde

format()

La méthode format() de Java Sting est utilisée pour formater la chaîne. Il existe deux variantes de la méthode format() de la chaîne Java.
- format(Locale l, String format, Object… args): Cette méthode formate la chaîne en utilisant la locale, le format de chaîne spécifié et les arguments.
- format(String format, Object… args): Cette méthode formate la chaîne en utilisant le format de chaîne spécifié et les arguments.
```
package com.journaldev.examples;

import java.util.Locale;

/**
 * Java String format
 * 
 * @author pankaj
 *
 */
public class StringFormatExample {

	public static void main(String[] args) {
		
		String s = "journaldev.com";
		// %s est utilisé pour ajouter la chaîne
		System.out.println(String.format("Ceci est %s", s));
		
		// en utilisant la locale comme Locale.US
		System.out.println(String.format(Locale.US, "%f", 3.14));
	}
}
```
Résultat du programme ci-dessus :
```
Ceci est journaldev.com
3,140000
```

substring()

Cette méthode renvoie une partie de la chaîne basée sur des indexes spécifiés.

package com.journaldev.examples;

/**
 * Java String substring
 *
 */
public class StringSubStringExample {

	public static void main(String[] args) {
		
		String s = "Ceci est journaldev.com";
		s = s.substring(8,18);
		System.out.println(s);
	}
}

Concaténation de chaînes

La concaténation de chaînes est une opération très basique en Java. Les chaînes peuvent être concaténées en utilisant l’opérateur « + » ou en utilisant la méthode concat().

package com.journaldev.examples;

/**
 * Java String concatenation
 * 
 * @author pankaj
 *
 */
public class StringConcatExample {

	public static void main(String[] args) {
		
		String s1 = "Hello";
		String s2 = "World";
		String s3 = s1 + s2;
		//utilisation de l'opérateur +
		System.out.println("Using + operator: ");
		System.out.println(s3);
		
		//utilisation de la méthode concat
		System.out.println("Using concat method: ");
		System.out.println(s1.concat(s2));

	}

}

La sortie du programme ci-dessus est :

Using + operator: 
HelloWorld
Using concat method: 
HelloWorld

Vérifiez ce message pour plus d’informations sur la Concaténation de chaînes en Java.

Pool de chaînes Java

La gestion de la mémoire est l’aspect le plus important de tout langage de programmation. La gestion de la mémoire pour les chaînes de caractères en Java est un peu différente des autres classes. Pour rendre Java plus efficace en termes de mémoire, la JVM a introduit une zone mémoire spéciale pour les chaînes de caractères appelée le pool de chaînes constantes. Lorsque nous créons une chaîne littérale, il vérifie si une chaîne identique existe déjà dans le pool de chaînes ou non. Si elle existe, il renvoie la référence de la chaîne existante du pool de chaînes. Jetons un coup d’œil à l’exemple de programme ci-dessous.

package com.journaldev.examples;

/**
 * Java String Pool Example
 * 
 */
public class StringPoolExample {

	public static void main(String[] args) {
		
		String a = "abc";
		String b = "abc";
		String c = "def";
		
		//même référence
		if (a==b) {
			System.out.println("Both string refer to the same object");
		}
		
		//référence différente
		if (a==c) {
			System.out.println("Both strings refer to the same object");
		}else {
			System.out.println("Both strings refer to the different object");
		}

	}

}

La sortie du programme ci-dessus est:

Both string refer to the same object
Both strings refer to the different object

Vérifiez cette publication pour en savoir plus sur le Pool de chaînes Java.

Méthode intern() de String

Lorsque nous créons une chaîne en utilisant une chaîne littérale, elle est créée dans le pool de chaînes, mais que se passe-t-il si nous créons une chaîne en utilisant le mot clé « new » avec la même valeur déjà présente dans le pool de chaînes ? Pouvons-nous déplacer la chaîne de la mémoire heap vers le pool de chaînes ? Pour cela, la méthode intern() est utilisée et elle renvoie une représentation canonique de l’objet de chaîne. Lorsque nous appelons la méthode intern() sur un objet de chaîne créé à l’aide du mot clé « new », elle vérifie s’il existe déjà une chaîne avec la même valeur dans le pool ? Si oui, elle renvoie la référence de cet objet de chaîne du pool. Sinon, elle crée une nouvelle chaîne avec le même contenu dans le pool et renvoie la référence.

package com.journaldev.examples;

/**
 * Java String intern
 * 
 * @author pankaj
 *
 */
public class StringInternExample {

	public static void main(String[] args) {
		
		String s1 = "pankaj";
		String s2 = "pankaj";
		String s3 = new String("pankaj");
		
		System.out.println(s1==s2);//true
		System.out.println(s2==s3);//false
		
		String s4 = s3.intern();
		System.out.println(s1==s4);//true

	}

}

Consultez cet article pour en savoir plus sur la méthode intern de Java String.

Avantages de l’immutabilité de String

Certains des avantages de la classe String immutable sont les suivants :

Constant Pool de String, ce qui permet d’économiser de la mémoire.
Sécurité car elle ne peut pas être modifiée.
Sûreté de fonctionnement avec les threads
Sécurité du chargement de classe

Consultez cet article pour en savoir plus sur les avantages de l’immutabilité de String.

Java 8 String join()

A new static method join() has been added in String class in Java 8. This method returns a new String composed of copies of the CharSequence elements joined together with a copy of the specified delimiter. Let’s look at an example to understand it easily.

List<String> words = Arrays.asList(new String[]{"Hello", "World", "2019"});
String msg = String.join(" ", words);
System.out.println(msg);

Résultat : Hello World 2019

Méthodes String de Java 9

Deux méthodes ont été ajoutées à la classe String dans la version Java 9. Il s’agit de codePoints() et chars(). Les deux méthodes renvoient un objet IntStream sur lequel nous pouvons effectuer certaines opérations. Jetons un coup d’œil rapide à ces méthodes.

String s = "abc";

s.codePoints().forEach(x -> System.out.println(x));

s.chars().forEach(x -> System.out.println(x));

Résultat :

Java 11 Nouvelles méthodes de la classe String

Il existe de nombreuses nouvelles méthodes ajoutées dans la classe String dans la version Java 11.

isBlank() – retourne true si la chaîne est vide ou ne contient que des points de code d’espace blanc, sinon false.
lines() – retourne un flux de lignes extraites de cette chaîne, séparées par des terminaisons de ligne.
strip(), stripLeading(), stripTrailing() – pour supprimer les espaces blancs initiaux et finaux de la chaîne.
repeat() – retourne une chaîne dont la valeur est la concaténation de cette chaîne répétée un nombre donné de fois.

Jetons un coup d’œil à un exemple de programme pour ces méthodes.

package com.journaldev.strings;

import java.util.List;
import java.util.stream.Collectors;

/**
 * JDK 11 New Functions in String class
 * 
 * @author pankaj
 *
 */
public class JDK11StringFunctions {

	public static void main(String[] args) {
		// isBlank()
		String s = "abc";
		System.out.println(s.isBlank());
		s = "";
		System.out.println(s.isBlank());

		// lines()
		String s1 = "Hi\nHello\rHowdy";
		System.out.println(s1);
		List lines = s1.lines().collect(Collectors.toList());
		System.out.println(lines);

		// strip(), stripLeading(), stripTrailing()
		String s2 = "  Java,  \tPython\t ";
		System.out.println("#" + s2 + "#");
		System.out.println("#" + s2.strip() + "#");
		System.out.println("#" + s2.stripLeading() + "#");
		System.out.println("#" + s2.stripTrailing() + "#");

		// repeat()
		String s3 = "Hello\n";
		System.out.println(s3.repeat(3));
		s3 = "Co";
		System.out.println(s3.repeat(2));

	}

}

Sortie:

false
true
Hi
Hello
Howdy
[Hi, Hello, Howdy]
#  Java,  	Python	 #
#Java,  	Python#
#Java,  	Python	 #
#  Java,  	Python#
Hello
Hello
Hello

CoCo

C’est tout sur la classe String en Java, ses méthodes et des exemples de manipulation de chaîne.

Vous pouvez consulter plus d’exemples de chaînes sur notre référentiel GitHub.

Référence : Documentation de l’API

Source:
https://www.digitalocean.com/community/tutorials/java-string

Utilisation de littéraux de chaîne

Utilisation du nouveau mot-clé

split()

contains(CharSequence s)

longueur()

remplacer()

format()

substring()