Strings

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 (vous pouvez trouver ici une description exhaustive)

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

Quelques méthodes utiles: countTokens(), hasMoreTokens(), nextToken()

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(int index, char ch);
•    d’accès à un caractère d'une position donnée : charAt(int index);
•    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(int offset, String str),
•    de remplacement d’une partie par une chaîne donnée : replace(int start, int end, String str),
•    de conversion de StringBuffer en String : toString().
•    ensureCapacity(int minimumCapacity)

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());
        }
    }
}