7.    Les chaînes de caractères

La classe String est déclarée final - on ne peut pas créer des classes dérivée de cette classe

7.1    Fonctionnalités de base

String s = "Hello";   

String s1 = new String();                //  chaîne vide
String s2 = new String ("Hello");    //    la référence à une chaîne contenant copie de la constante
String s3 = new String(s2)            //    la référence à une chaîne contenant copie de s2
char datac[ ] = {'p', 'a', 'r', 'c', 's'};
String s4 = new String(datac);         //tableau entier – "parcs"
String s5 = new String(datac 1,3)    //tableau debut, longuer – "arc"

Un objet de type String n’est pas modifiable.

La méthode length()

public class Slen {
    public static void main(String[] arg){
        String s = new String("Hello world");
        System.out.println("the string ("+s+") contains "+
                            s.length()+" characters");
    }
}

L’opérateur +

La méthode charAt()

public class ScharAt{
    public static void main(String[] arg){
        String s = "Hello";
        for(int i=0;i<s.length();i++)
            System.out.println(s.charAt(i));       
    }
}

7.2    Comparaisons de chaînes


7.2.1    Les opérateurs == et !=

On compare des références

public class Test{
    public static void main(String[] arg){
        String s1 = "test";
        String s2 = "test";
        String s3 = new String("test");
        System.out.println((s1==s2)+"\t"+(s1 == s3));
    }
}

7.2.2    La méthode equals()

Compare le contenu de deux chaînes.

public class Test{
    public static void main(String[] arg){
        String s1 = new String("test");
        String s2 = new String("test");
        String s3 = new String("Test");
        System.out.println((s1==s2)+"\t"+ s1.equals(s2));
        System.out.println(s1.equals(s3)+"\t"+ s1.equalsIgnoreCase(s3));
    }
}

7.2.3    Les méthodes compareTo() et compareToIgnoreCase()

comparaisons lexicographiques de chaînes

s1.compareTo(s2)
fournit comme résultat:
•    un entier négatif si s1 arrive avants s2;
•    un entier nul si chaîne1 et chaîne2 sont égales (on a alors s1.equals(s2)),
•    un entier positif si s1 arrive après s2

public class Test{
    public static void main(String arg[]){
        String names [ ] = {"Rose","Anabelle", "Gerard", "Francoise", "Erik","Constance"},name;
        for(boolean ok = false; !ok; ){
            ok=true;                                                // pas d'echanges au debut
            for(int i = 0; i < names.length-1; i++){
                if(names[i].compareTo(names[i+1])>0){        //comparaisons
                    name = names[i];                            //changer le places
                    names[i] = names[i+1];
                    names[i+1] = name;
                    ok = false;                                    // l'echange memorisee
                }
            }
        }
        for(String nm:names)
            System.out.println (nm + "\t has "+nm.length()+" letters");
    }
}

7.3    Conversion vers une chaîne de caractères


double d = 27.3
String s= String.valueOf(d) ; // fournit une chaîne obtenue de la valeur contenue dans d, soit ici "27.3"

En fait, cette affectation produit le même résultat que l’affectation :

s = "" + n ; // utilisation artificielle d’une chaîne vide pour pouvoir recourir à l’opérateur +

Les expressions suivantes sont équivalentes:

String.valueOf(Obj)
Obj.toString()
""+Obj

7.4    Conversions d’une chaîne en un type primitif


String s = "1234" ;
int n = Integer.parseInt(s) ;

 Byte.parseByte,  Short.parseShort,  Integer.parseInt,  Long.parseLong,  Float.parseFloat,  Double.parseDouble.

Contrairement aux conversions inverses présentées précédemment, celles-ci peuvent ne pas aboutir.

"3." convient pour un double, pas pour un int,
"34z3" conduira toujours à une erreur



Expression

Résultat

Remarque

Integer.parseInt("0", 10)

0

 

Integer.parseInt("473", 10)

473

 

Integer.parseInt("-0", 10)

0

 

Integer.parseInt("-FF", 16)

-255

système hexadécimale

Integer.parseInt("1100110", 2)

102

système binaire

Integer.parseInt("2147483647", 10)

2147483647

 

Integer.parseInt("-2147483648", 10)

-2147483648

 

Integer.parseInt("2147483648", 10)

jette une NumberFormatException

 

Integer.parseInt("99", 8)

jette une NumberFormatException

système octale

Integer.parseInt("Kona", 10)

jette une NumberFormatException

 

Integer.parseInt("Kona", 27)

411787,

système en racine 27

           Tab. 7.1 Exemples des méthodes de conversion d'une chaîne en int

7.5    Quelque méthodes utiles


Méthode

Fonctionnalité

public char charAt(int index)

Récupère un caractère particulier dans la chaîne

public boolean endsWith(String suffix)

Vérifie si la chaîne se termine par un siffixe

public int indexOf(String str)

Cherche la première occurrence d'une sous-chaîne dans la chaîne

public int indexOf(String str,int fromIndex)

Cherche la première occurrence d'une sous-chaîne dans la chaîne à partir de la position fromIndex

public int lastIndexOf(String str)

Cherche la dernière occurrence d'une sous-chaîne dans la chaîne

public String replace(char oldChar,char newChar)

Remplace toutes les occurrences d'un caratère dans une chaîne par un autre caractère

public boolean startsWith(String prefix)

Verifie si la chaîne débute par un préfixe

public String substring(int beginIndex)

Retourne une sous chaîne de la chaîne qui debute à la position beginIndex

public String substring(int beginIndex,int endIndex)

Retourne une sous chaîne de la chaîne qui debute à la position beginIndex et finit à la position endIndex

public String toUpperCase()

Convertit la chaîne en lettres majuscules

public String toLowerCase()

Convertit la chaîne en lettres miniscules

public String trim()

Supprime les espaces redondantes de la chaîne

             Tab. 7.2 Quelques méthodes utiles pour manipulation des chaînes


7.6    La classe StringTokenizer

Délimiteur - espaces

import java.util.StringTokenizer;
public class Test{
    public static void main(String arg[]){
        String s = "Java is a general-purpose, class-based, and object-oriented language";
        StringTokenizer st = new StringTokenizer(s);
        while(st.hasMoreTokens()){
            String word = st.nextToken();
            System.out.println(word);
        }
    }
}

Délimiteurs   les caractères '/', ':' et '.'

import java.util.StringTokenizer;
public class Test{
    public static void main(String arg[]){
        String s1 = "http://www.javasoft.com";
        StringTokenizer st1 = new StringTokenizer(s1,"/:.");
        while(st1.hasMoreTokens()){
            String word = st1.nextToken();
            System.out.println(word);
        }
    }
}

7.7    La classe StringBuffer

Les objets sont modifiables.
La classe StringBuffer dispose de fonctionnalités classiques mais elle n’a aucun lien avec String et ses méthodes ne portent pas toujours le même nom.

•    de modification d’un caractère d'une position donnée: setCharAt();
•    d’accès à un caractère de rang donné : charAt();
•    d’ajout d’une chaîne en fin : la méthode append() accepte des arguments de tout type primitif et de type String;
•    d’insertion d’une chaîne en un emplacement donné : insert(),
•    de remplacement d’une partie par une chaîne donnée : replace(),
•    de conversion de StringBuffer en String : toString().
•    ensureCapacity()


public class Test{
    public static void main(String arg[]){
        StringBuffer sBuf = new StringBuffer ("new ") ;
        sBuf.append("test string buffer");
        System.out.println (sBuf) ;
        sBuf.setCharAt (3, 'J'); System.out.println (sBuf) ;
        sBuf.append (" 2") ; System.out.println (sBuf) ;
        sBuf.insert (3, "langage ") ; System.out.println (sBuf) ;
    }
}

7.8    Les types énumérés

enum Coin { PENNY, NICKEL, DIME, QUARTER }
enum Weekday {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
}

Weekday est une classe. Les 7 constantes sont des instances (et non des variables membres) finales, donc non modifiables. Tous les types énumérés, sont dérivée de la classe Enum.

Weekday d1,d2;
d1 = Weekday. MONDAY;
d2 = Weekday. TUESDAY;

On peut utiliser indifféremment l'opérateur == ou la méthode equals().
Il n’est pas possible d’utiliser les opérateurs arithmétiques.
On peut recourir à la méthode compareTo() qui se fonde sur l’ordre dans lequel on a déclaré les constantes.

System.out.println(d1+"");
va afficher la chaîne de caractères " MONDAY ".

Weekday.valueOf("TUESDAY")
fournira la référence à l’objet constant Weekday. TUESDAY.

public class Test{
    enum Weekday {
        SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
    }
    public static void main(String[] arg){
        Weekday  d1,d2,d3;
        d1 = Weekday.MONDAY;
        d2 = Weekday.MONDAY ;
        d3 = Weekday.WEDNESDAY;
        System.out.println("operator=:\t"+(d1==d2)+"\t"+(d1==d3));
        System.out.println("method equal():\t"+d1.equals(d2));   
        if(d1.compareTo(d3)<0){
            System.out.println(d1+" is before "+d3);
        }
    }
}

public class Test {
    enum Coin { PENNY, NICKEL, DIME, QUARTER }
    public static void main(String[] args) {
        Coin coin = Coin.NICKEL;
        switch (coin){
            case PENNY : System.out.println("1 cent"); break;
            case NICKEL : System.out.println("5 cents"); break;
            case DIME : System.out.println("10 cents"); break;
            case QUARTER: System.out.println("25 cents"); break;
            default : System.out.println("not possible");
        }
    }
}

Il est impossible d’utiliser la boucle for usuelle. En revanche, on peut recourir à la boucle for...each (après la creation d'un tableau par la méthode value() )

public class Test{
    enum Weekday {
        MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
    }
    public static void main(String[] arg){
        for(Weekday d: Weekday.values()){
            System.out.print(d+"; ");
        }
    }
}

Il est possible de définir des méthodes spécifiques à l’intérieur de la classe

public class Test{
    enum Weekday {
        MONDAY, TUESDAY, WEDNESDAY, THURSDAY,
        FRIDAY, SATURDAY, SUNDAY;
        String workTime(){
            if(this ==SUNDAY ){
                return "10 - 14";
            }
            else
                if(this == SATURDAY){
                    return "10 - 18";
                }
            return "8 - 22";
        }
    }
    public static void main(String[] arg){
        System.out.println("Working time:");
        for(Weekday d: Weekday.values()){
            System.out.println(d+": "+d.workTime());           
        }
    }
}