Manipulation de chaînes de caractères en Java

Manipulation de caractères Les chaînes « Text Blocks »

Accès rapide :
La vidéo
Rappels sur les standards d'encodage de caractères
Utilisation du type java.lang.String
Séquences de caractères particulières
Comparaison de chaînes de caractères
Quelques méthodes de traitement de chaînes de caractères
Conversions types primitifs / chaînes de caractères

La vidéo

Cette vidéo vous montre comment utiliser les chaînes de caractères en Java. On y insiste sur l'aspect immuable des chaînes de caractères Java ainsi que sur la manière de correctement comparer deux chaînes. Quelques méthodes de la classe String vous sont aussi présentées.

Rappels sur les standards d'encodage de caractères

Pour un rappel sur les standards d'encodage de caractères, je vous renvoie vers le chapitre précédent qui traite de ce sujet : activez ce lien pour consulter ce chapitre.

Utilisation du type java.lang.String

Une chaîne de caractères s'introduit par le type String. L'ensemble des caractères de la chaîne sont compris entre deux double-guillemets. Voici un exemple de déclaration de chaînes de caractères.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 

public class Demo {
 
    public static final void main( String [] args ) {

        String firstName = "Diego";
        String lastName = "De La Vega";
        
        System.out.println( firstName + " - " + lastName );

    }
               
}

En fait le type String peut aussi s'écrire java.lang.String. Bien entendu, l'informaticien (étant fainéant), préferera le plus souvent la première approche. Voici un exemple de code montrant cette seconde écriture faisant apparaître le paquetage java.lang (la classe String est contenu dans le paquetage java.lang).

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 

public class Demo {
 
    public static final void main( String [] args ) {

        java.lang.String firstName = "Diego";
        java.lang.String lastName = "De La Vega";
        
        System.out.println( firstName + " - " + lastName );

    }
               
}

Contrairement aux types étudiés précédemment (int, long, float, double, boolean, ...), vous aurez noté que le type String commence par une majuscule. Cette remarque est pertinente. Les types commençant par une minuscule (int, ...) sont appelés types primitifs (ou parfois types scalaires). Les types commençant par des majuscules sont appelés types objets (classes, interfaces, enums, ...). Dans le cas de String, nous avons plus précisément à faire à une classe.

Pour l'heure, nous noterons qu'une seule différence entre types primitifs et types objets : les types objets exposent des méthodes, en quelques sortes des fonctions, alors que les types primitifs n'en exposent pas. A titre d'exemple, notez l'utilisation des méthodes toLowerCase et toUpperCase dans le code suivant.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 

public class Demo {
 
    public static final void main( String [] args ) {

        String firstName = "Diego";
        String lastName = "De La Vega";
        
        System.out.println( firstName.toLowerCase() + " - " + lastName.toUpperCase() );

    }
               
}

Comme vous le constatez sur l'exemple ci-dessus, il est possible de concaténer des chaînes de caractères avec l'opérateur +. Il est aussi possible d'utiliser l'opérateur +=, comme le montre ce nouvel exemple.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 

public class Demo {
 
    public static final void main( String [] args ) {

        String firstName = "Diego".toLowerCase();
        String lastName = "De La Vega".toUpperCase();
        String fullString = firstName + " " + lastName;
        fullString += " !";
        
        System.out.println( fullString );       // Affiche : diego DE LA VEGA !

    }
               
}

Séquences de caractères particulières

Tout comme nous l'avons vu, dans le chapitre précédent sur l'utilisation de caractères, il existe des séquences particulières permettant d'utiliser des caractères spéciaux ou non accessibles à partir de votre clavier.

 String str = "Hello\n";

 String str = "First\tSecond";

 String str = "Un \" au milieu";

 String str = "C:\\Folder\\file.txt";

 String str = "\u03c0 vaut environ 3.141592654";  // Un caractère PI en minuscule

 char c1 = '\n';    // Un retour à la ligne
 char c2 = '\t';    // Une tabulation
 char c3 = '\\';    // Tout simplement un \
 char c4 = '\'';    // Un caractère '

Comparaison de chaînes de caractères

L'opérateur == peut être utilisé entre deux chaînes de caractères. Pour autant il ne va pas forcément calculer ce à quoi vous vous attendez. A titre d'exemple, exécutez ce code.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 

public class Demo {
            
    public static void main( String [] args ) {
    
        String first = "toto";
        String temp = "to";
        String second = temp + temp;
        
        if ( first == second ) {
            System.out.println( "Les deux chaînes sont identiques" );
        }
    
    }
    
}

Comme vous l'avez certainement constaté, aucun affichage n'est produit : c'est normal. L'opérateur == utilisé sur des types objets (ici nos chaînes de caractères) ne regarde pas si les caractères des deux chaînes sont égaux deux à deux. Ce qu'il vérifie, c'est si les deux pointeurs (les deux adresses en mémoire) des deux variables first et second sont égaux ou non. Dit autrement on regarde si les deux variables pointent au même endroit en mémoire, si c'est le même objet.

En effet, toutes les variables basées sur des types objets (des types qui commencent par une majuscule, comme String) sont en fait des pointeurs (des adresses en mémoire) qui référencent des objets. Le meilleur moyen de valider qu'une chaîne de caractères est un pointeur et de compiler le programme suivant qui initialise str à l'adresse 0 (le pointeur nul). On spécifie une adresse initialisée à 0 en utilisant le mot clé réservé null. Comme tout mot clé réservé du langage, null doit s'écrire en minuscule.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 

public class Demo {
            
    public static void main( String [] args ) {
    
        String str = null;
        System.out.println( str );
    
    }
    
}

Du coup, la question que vous devez avoir en tête est la suivante : ok, mais comment comparer deux chaînes de caractères entre elles ? En fait, il vous faut utiliser une méthode de la classe String : la méthode equals. Analysez le code suivant et essayez de déduire les affichages qu'il produit.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
 22 
 23 
 24 
 25 
 26 

public class Demo {
            
    public static void main( String [] args ) {

        String temp = "to";
    
        String first = "toto";
        String second = temp + temp;
        String third = first;           // Copie de pointeur (aucune duplication de chaîne)
        String fourth = "toto";
        
        System.out.println( first == second );     
        System.out.println( first.equals( second ) );     

        System.out.println( first == third );     
        System.out.println( first.equals( third ) );     
    
        System.out.println( first == fourth );     
        System.out.println( first.equals( fourth ) );     

        System.out.println( first == "Java" );     
        System.out.println( first.equals( "Java" ) );     

    }
    
}

Nous allons maintenant vérifier vos déductions, avec l'affichage produit par le programme ci-dessus.

$> javac Demo.java
$> java Demo
false
true
true
true
true
true
false
false
$>

Quelques méthodes de traitement de chaînes de caractères

La conséquence directe de la remarque précédente, est que toute méthode de transformation de chaînes de caractères proposé par la classe String renvoient un résultat de type String : la nouvelle chaîne de caractère modifiée.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 

public class Demo {
            
    public static void main( String [] args ) {
    
        String original = "Diego De La Vega";
        String transformation = original.toUpperCase();
        
        System.out.println( transformation );                       // Affiche : DIEGO DE LA VEGA
        System.out.println( "Compact Sample".toLowerCase() );       // Affiche : compact sample
            
    }
    
}

Comme indiqué dans la note, il est possible de réaffecter le résultat d'une transformation à la variable, comme le montre l'exemple suivant.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 

public class Demo {
            
    public static void main( String [] args ) {
    
        String zorro = "Diego De La Vega";
        zorro = zorro.toLowerCase();
        
        System.out.println( zorro );           // Affiche : diego de la vega
            
    }
    
}

Le tableau suivant propose quelques méthodes utiles proposées par la classe String.

int l = "abcdef".indexOf( "cd" );  // 2
int l = "abcdef".indexOf( "gh" );  // -1

int l = "abcdab".lastIndexOf( "ab" );  // 4 
int l = "abcdab".lastIndexOf( "ij" );  // -1

int l = "toto".length();  // 4

String str = "abcdabcd".replace( "b", "e" );
System.out.println( str ); // aecdaecd

String [] parts = "19/01/2018".split( "/" );
System.out.println( parts[0] );  // 19
System.out.println( parts[1] );  // 01
System.out.println( parts[2] );  // 2018

String str = "abcdef".substring( 2, 4 );  // cd

String str = "  Toto  ".trim();  // Toto

String str = "Toto".toLowerCase();  // toto

String str = "Toto".toUpperCase();  // TOTO

Voici un petit exemple d'utilisation de méthodes de la classe String.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
 22 
 23 
 24 
 25 
 26 
 27 
 28 

public class Demo {
            
    public static void main( String [] args ) {
    
        String message = "This is a String with Unicode characters (\u03c0)";
        System.out.println( message );
        
        String upper = message.toUpperCase();
        System.out.println( upper );
        String lower = message.toLowerCase();
        System.out.println( lower );
        System.out.println( message );
        
        String subPart = message.substring( 22, 29 );
        System.out.println( subPart + "!" );
        
        String [] parts = message.split( " " );
        for (String str : parts) {
            System.out.print( str + " - " );
        }
        System.out.println();
        
        String replacement = message.replace( "String", "Truc" );
        System.out.println( replacement );            

    }
    
}

Conversions types primitifs / chaînes de caractères

Il est possible de convertir des valeurs numériques (de type int, long, float, double, ...) en chaînes de caractères et réciproquement. Idem pour les booléen. Pour ce faire, il faut utiliser les méthodes statiques proposées par la classe enveloppante (Wrapped Class) associée à chaque type primitif. Le tableau suivant précise le nom de ces classes

Voici un exemple d'utilisation de ces classes.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 

public class Demo {
            
    public static void main( String [] args ) {
    
        String strValue = "123";
        int value = Integer.parseInt( strValue );
        strValue = "3.141592654";
        double value2 = Double.parseDouble( strValue );
        System.out.println( value + " - " + value2 );
        
        String finalString = value + "";
        finalString += " ";                         
        finalString += Double.toString( value2 );
        System.out.println( finalString );
        
        // Exemple d'affichage formaté : les différents formats seront vus dans un prochain chapitre
        String strFinal2 = String.format( "%05d [%05.2f]", value, value2 );
        System.out.println( strFinal2 );
    }
    
}

Et voici le résultat produit par cet exemple.

$> javac Demo.java
$> java Demo
123 - 3.141592654
123 3.141592654
00123 [03,14]
$> 

Manipulation de caractères Les chaînes « Text Blocks »