Chaîne en Java

Une chaîne est une séquence de caractères, mais en Java, ils sont traités comme des objets et de nature immuable ; java fournit le package java.lang.String avec différentes méthodes disponibles pour opérer sur une chaîne, mais nous pouvons également créer une chaîne mutable en java.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Comment définir une chaîne en Java ?

Nous pouvons le définir en utilisant la chaîne littérale et les nouveaux mots-clés. Mais la différence est littérale, le nouvel objet ne sera pas créé à moins qu'il ne soit pas disponible dans le pool de chaînes. Cependant, le mot-clé new créera toujours le nouvel objet quel que soit le pool de constantes de chaîne, car il crée une chaîne dans la zone du tas.

• Chaîne mutable
• Chaîne immuable

Comment créer une chaîne en Java ?

En Java, nous pouvons définir une chaîne de deux manières qui sont les suivantes :

• En utilisant une chaîne littérale
• En utilisant un nouveau mot-clé

1. Chaîne littérale

La chaîne que nous créons en utilisant un littéral va directement au pool de constantes de chaîne. Cela signifie que si la chaîne demandée est déjà présente dans le pool de chaînes, alors la chaîne existante sera renvoyée si la chaîne demandée n'existe pas, alors seule une nouvelle instance de la chaîne sera créée et placée dans le pool pour référence future. La JVM effectue toutes ces choses.

Syntaxe :

String s="abc";
String s1 = "abc" ;

Dans le scénario ci-dessus, un seul objet serait créé dans le pool de chaînes car la JVM ne pourra pas trouver l'objet demandé, elle le créera donc et le placera dans le pool, et s1 pointera uniquement vers cette référence. pour une utilisation ultérieure. Ainsi, les chaînes littérales économisent également de la mémoire en ne créant plus la même instance. Par conséquent, ils rendent notre mémoire de code efficace.

2. nouveau mot-clé

En Java, nous utilisons le mot-clé new pour créer un nouvel objet. Chaque fois que nous utilisons un nouveau mot-clé, cela créera un nouvel objet pour nous. De plus, un objet créé à l'aide d'un nouveau mot-clé est placé dans la zone de mémoire tas.

Syntaxe :

String s = new Stirng("abc");

Dans l'exemple ci-dessus, cet objet sera placé dans la zone de mémoire tas, pas dans le pool de chaînes, car nous le créons à l'aide du nouveau mot-clé.

Exemple :

public class Main {
public static void main(String[] args) {
String s = "abc";
String s1 = "abc";
String ss = new String("abc");
System.out.println("Output will be :: " + s + " "+ s1 +" "+ ss);
}
}

Sortie :

Règles et règlements pour les chaînes en Java

Il est immuable, nous ne pouvons donc pas modifier sa valeur une fois attribuée. Donc, pour créer une chaîne mutable, nous devons utiliser un tampon de chaîne pour cela.

Quelques points sont à retenir :

•  Lors de la définition d'une chaîne, assurez-vous qu'elle est toujours entre guillemets doubles.
• Ils sont immuables, c'est-à-dire que la valeur ne peut pas être modifiée une fois attribuée.
• L'opérateur « + » peut concaténer deux ou plusieurs chaînes.
• On peut affecter directement la chaîne à une variable sans appeler son constructeur.

Méthodes de classe String en Java

Les différentes méthodes disponibles sont les suivantes :

• trim()
• versUpperCase
• en minuscules
• valueOf(int valeur)
• toLowerCase(Locale l)
• stagiaire()
• indexOf(int ch)
• indexOf(Sous-chaîne de chaîne, int fromIndex)
• indexOf(Sous-chaîne de chaîne)
• split(String regex, limite int)
• concat(String str)
• indexOf(int ch, int fromIndex)
• longueur()
• est égal à(Objet un autre)
• join (délimiteur CharSequence, Iterable)
• estEmpty()
• remplacer(char ancien, char nouveau)
• equalsIgnoreCase (Chaîne une autre)
• split (expression régulière de chaîne)
• toUpperCase(Locale l)
• contient (CharSequence s)
• charAt(int index)
• remplacer(CharSequence ancien, CharSequence nouveau)
• join (délimiteur CharSequence, éléments CharSequence…)
• sous-chaîne (int startIndex)
• ubstring(int startIndex, int endIndex)
• La classe String en Java implémente une interface différente nommée
• Sérialisable
• Comparable
• CharSequence

De plus, la classe string implémente une interface supplémentaire, c'est-à-dire l'interface CharSequence ; StringBuilder et String Buffer implémentent également cette interface. StringBuffer et StringBuilder sont utilisés pour créer la chaîne mutable en Java.

Exemple – Utilisation de StringBuffer

Code :

public class Demo{
public static void main(String[] args) {
StringBuffer sb=new StringBuffer("creating string ");
sb.append("executed");//original string will get chnage
System.out.println("Result is " +sb);//it will print creating string executed
}
}

Sortie :

Exemple – Utilisation de StringBuilder

Code :

public class Main{
public static void main(String[] args) {
StringBuilder sb=new StringBuilder("Creating string");
sb.append(" using string Builder");//original will get change
System.out.println("Result is "+sb);
}
}

Sortie :

Exemples

Ci-dessous les exemples :

Exemple n°1

Code :

public class Main{
public static void main(String[] args) {
String s1="demoforsting";
System.out.println("String is " +s1.substring(2,4));
System.out.println( "with one parameter " +s1.substring(2));
}
}

Sortie :

Example #2

Code:

public class Demo{
public static void main(String[] args) {
String s1="abc";
String s2="abc";
String s3="ABC";
String s4="java";
System.out.println("Result is " +s1.equals(s2));//true
System.out.println("Result is " +s1.equals(s3));//false
System.out.println("Result is " +s1.equals(s4));//false
}
}

Output:

Example #3

Code:

public class Demo{
public static void main(String[] args) {
String s1="convert it into uppercase";
String upper=s1.toUpperCase();
System.out.println("result is "+upper);
}
}

Output:

Example #4

Code:

public class Demo{
public static void main(String[] args) {
String s1="CONVERT IT INTO LOWER CASE";
String s1upper=s1.toLowerCase();
System.out.println("result is "+s1upper);
}
}

Output:

Example #5

Code:

public class Main{
public static void main(String[] args) {
String name="Demo to check contains method";
System.out.println("Result for conatins mehtod is " +name.contains("check"));
System.out.println("Result for conatins mehtod is " +name.contains("method"));
System.out.println("Result for conatins mehtod is " +name.contains("move"));
}
}

Output:

Example #6

Code:

public class Main{
public static void main(String[] args) {
String str1 = "Demo for";
String str2 = "Concat";
String str3 = "Method";
// doing for string one
String str4 = str1.concat(str2);
System.out.println("Result is "+str4);
// for multiple string
String str5 = str1.concat(str2).concat(str3);
System.out.println("Result is "+str5);
}
}

Output:

Example #7

Code:

public class Main {
public static void main(String[] args) {
String s1 =" Provide space to see use of trim method in java ";
System.out.println(s1.length());
System.out.println("without trim output is "+s1); //Not using trim here
String tr = s1.trim();
System.out.println(tr.length());
System.out.println("with trim output is "+tr); //using trim here
}
}

Output:

Conclusion

So java string is an immutable object that provides security in various aspects like URL reading, database username and password, port, and many other things. But if we want to create a mutable string, we should use a string buffer and builder.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!