Classes d'assistance pour travailler avec des chaînes en Java

1. StringTokenizerclasse

Et maintenant, quelques scénarios plus courants impliquant de travailler avec des chaînes. Comment scinde-t-on une chaîne en plusieurs parties ? Il y a plusieurs moyens de le faire.

split()méthode

La première façon de diviser une chaîne en plusieurs parties consiste à utiliser la split()méthode . Une expression régulière qui définit une chaîne de délimitation spéciale doit être passée en argument. Vous apprendrez ce qu'est une expression régulière dans la quête Java Multithreading .

Exemple:

String str = "Good news everyone!";
String[] strings = str.split("ne");
System.out.println(Arrays.toString(strings));

["Good ", "ws everyo", "!"]

Simple, mais parfois cette approche est excessive. S'il y a beaucoup de délimiteurs (par exemple, des espaces, des sauts de ligne, des tabulations, des points), vous devez construire une expression régulière assez complexe. Il est difficile à lire et donc difficile à modifier.

StringTokenizerclasse

Java a une classe spéciale dont le travail consiste à diviser une chaîne en sous-chaînes.

Cette classe n'utilise pas d'expressions régulières : à la place, vous transmettez simplement une chaîne composée de délimiteurs. L'avantage de cette approche est qu'elle ne brise pas toute la chaîne en morceaux d'un seul coup, mais se déplace plutôt du début à la fin une étape à la fois.

La classe a un constructeur et deux méthodes importantes. Nous passons au constructeur une chaîne que nous divisons en parties et une chaîne composée d'un ensemble de caractères de délimitation.

String nextToken()

boolean hasMoreTokens()

Cette classe rappelle en quelque sorte la classe Scanner, qui possède également des méthodes nextLine()et hasNextLine().

Vous pouvez créer un StringTokenizerobjet avec cette commande :

StringTokenizer name = new StringTokenizer(string, delimiters);

Où stringest la chaîne à diviser en parties. Et delimitersest une chaîne, et chaque caractère qu'elle contient est traité comme un délimiteur. Exemple:

String str = "Good news everyone!";

StringTokenizer tokenizer = new StringTokenizer(str,"ne");
while (tokenizer.hasMoreTokens())
{
   String token = tokenizer.nextToken();
   System.out.println(token);
}

Good 
ws 
v
ryo
!

Notez que chaque caractère de la chaîne passée comme deuxième chaîne au StringTokenizerconstructeur est considéré comme un séparateur.

2. String.format()méthode et StringFormatterclasse

Une autre méthode intéressante de la classe String est format().

Disons que vous avez diverses variables stockant des données. Comment les affichez-vous à l'écran sur une seule ligne ? Par exemple, nous avons des données (colonne de gauche) et la sortie souhaitée (colonne de droite) :

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

User = {name: Amigo, age: 12 years, friend: Diego, weight: 200 kg.}

Votre code ressemblera probablement à ceci :

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

System.out.println("User = {name: " + name + ", age:" + age + " years, friend: " + friend+", weight: " + weight + " kg.}");

Un tel code n'est pas très lisible. Et si les noms de variables étaient plus longs, alors le code deviendrait encore plus difficile :

class User {
    ......
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public List<String> getFriends() {
        return friends;
    }

    public ExtraInformation getExtraInformation() {
        return extraInformation;
    }
}

User user = new User();

System.out.println("User = {name: " + user.getName() + ", age:" + user.getAge() + " years, friend: " + user.getFriends().get(0) + ", weight: " + user.getExtraInformation().getWeight() + " kg.}");

Pas très lisible, n'est-ce pas ?

Mais c'est une situation courante dans les programmes du monde réel, donc je veux vous parler d'une façon d'écrire ce code plus simplement et de manière plus concise.

String.format

La classe String a une format()méthode statique : elle vous permet de spécifier un modèle pour assembler une chaîne avec des données. L'aspect général de la commande est le suivant :

String name = String.format(pattern, parameters);

Exemple:

String.format("Age=%d, Name=%s", age, name);

Age=12, Name=Amigo

String.format("Width=%d, Height=%d", width, height);

Width=20, Height=10

String.format("Fullname=%s", name);

Fullname=Diego

Le format()premier paramètre de la méthode est une chaîne de format qui contient tout le texte souhaité ainsi que des caractères spéciaux appelés spécificateurs de format (tels que %det %s) aux endroits où vous devez insérer des données.

La format()méthode remplace ces spécificateurs de format %set %dpar les paramètres qui suivent la chaîne de format dans la liste de paramètres. Si nous voulons insérer une chaîne, nous écrivons %s. Si nous voulons insérer un nombre, le spécificateur de format est %d. Exemple:

String s = String.format("a=%d, b=%d, c=%d", 1, 4, 3);

Voici une courte liste de spécificateurs de format pouvant être utilisés dans la chaîne de format :

%s

%d

%f

%b

%c

%t

%%

Ces spécificateurs indiquent le type de données, mais il existe également des spécificateurs qui indiquent l'ordre des données. Pour obtenir un argument par son numéro (la numérotation commence à partir de un), il faut écrire " " au lieu de " ". Exemple:%1$d%d

String s = String.format("a=%3$d, b=%2$d, c=%d", 11, 12, 13);

%3$dobtiendra le 3ème argument, %2$dobtiendra le deuxième argument et %dobtiendra le tout premier argument. Les spécificateurs de format %set %dfont référence à des arguments indépendamment des spécificateurs tels que %3$dou%2$s

3. Piscine à cordes

Chaque chaîne spécifiée dans le code en tant que littéral de chaîne est stockée dans une zone de mémoire appelée pendant StringPooll'exécution du programme. StringPoolest un tableau spécial pour stocker des chaînes. Son but est d'optimiser le stockage des chaînes :

Tout d'abord, les chaînes spécifiées dans le code doivent être stockées quelque part, n'est-ce pas ? Le code se compose de commandes, mais les données (en particulier les grandes chaînes) doivent être stockées en mémoire séparément du code. Seules les références aux objets chaîne apparaissent dans le code.

Deuxièmement, tous les littéraux de chaîne identiques doivent être stockés en mémoire une seule fois. Et c'est comme ça que ça marche. Lorsque votre code de classe est chargé par la machine Java, tous les littéraux de chaîne sont ajoutés au StringPools'ils ne s'y trouvent pas déjà. S'ils sont déjà là, nous utilisons simplement une référence de chaîne du fichier StringPool.

Ainsi, si vous affectez le même littéral à plusieurs Stringvariables de votre code, alors ces variables contiendront la même référence. Un littéral ne sera ajouté qu'une StringPoolseule fois. Dans tous les autres cas, le code obtiendra une référence à la chaîne déjà chargée dans le fichier StringPool.

Voici à peu près comment cela fonctionne :

String a = "Hello";
String b = "Hello";
String c = "Bye";

String[] pool = {"Hello", "Bye"};
a = pool[0];
b = pool[0];
c = pool[1];

C'est pourquoi les variables aet bstockeront les mêmes références.

intern()méthode

Et la meilleure partie est que vous pouvez ajouter par programmation n'importe quelle chaîne au fichier StringPool. Pour ce faire, il vous suffit d'appeler la méthode Stringde la variable .intern()

La intern()méthode ajoutera la chaîne au StringPoolsi elle n'y est pas déjà et renverra une référence à la chaîne dans le StringPool.

Si deux chaînes identiques sont ajoutées à l' StringPoolaide de la intern()méthode, la méthode renvoie la même référence. Cela peut être utilisé pour comparer des chaînes par référence. Exemple:

String a = new String("Hello");
String b = new String("Hello");
System.out.println(a == b);

false

String a = new String("Hello");
String b = new String("Hello");

String t1 = a.intern();
String t2 = b.intern();
System.out.println(a == b);
System.out.println(t1 == t2);

false
true

Il est peu probable que vous utilisiez souvent cette méthode, mais les gens adorent poser des questions à ce sujet lors d'entretiens . Il vaut donc mieux le savoir que ne pas le savoir.