Médiaforma

All posts tagged string

Plusieurs types de données peuvent être utilisés en PHP :

  • Booléen : c’est le type le plus simple. Il peut valoir TRUE ou FALSE (ces deux mots sont insensibles à la casse).
  • Entier : un nombre entier peut être spécifié en décimal (1234), en octal (0123) ou en hexadécimal (0x1F).
  • Décimal : un nombre décimal peut être spécifié sous une forme traditionnelle (1.46) ou en virgule flottante (1.2e3 ou 6E-9).
  • Chaîne : elle peut être délimitée par des guillemets ou par des apostrophes. Utilisez le caractère d’échappement antislash (\) pour insérer un guillemet ou une apostrophe dans une chaîne délimitée (respectivement) par des guillemets ou des apostrophes.
  • Tableau : il peut être constitué d’une suite de valeurs individuelles ou d’une suite de couples clé=>valeur. Nous y reviendrons par la suite.
  • Objet : pour définir un objet, vous devez instancier une classe en utilisant le mot-clé new. Les fonctions membres sont accédées avec l’opérateur -> et les variables membres avec l’expression $this->var_membre. Nous y reviendrons par la suite.
  • Ressource : il s’agit d’un type particulier qui fait référence à une ressource externe. Consultez cette page pour en savoir plus : http://www.php.net/manual/fr/resource.php. Nous y reviendrons par la suite.
  • NULL : ce type représente une variable sans valeur. Une variable est de type NULL si :
    • On lui a affecté la constante NULL ;
    • Elle n’a pas encore reçu de valeur ;
    • Elle a été effacée avec la fonction unset().

Pour tester si une donnée est d’un certain type (ou peut être convertie dans ce type), vous utiliserez des fonctions PHP prédéfinies :

Fonction Effet
is_array() Teste si l’argument est un tableau
is_bool() Teste si l’argument est un booléen
is_float() Teste si l’argument est un nombre réel
is_int() Teste si l’argument est un nombre entier
is_null() Teste si l’argument est nul
is_numeric() Teste si l’argument est numérique
is_object() Teste si l’argument est un objet
is_string() Teste si l’argument est une chaîne

 

Voici quelques exemples :

$ch="ceci est une chaîne"; // La fonction is_string($ch) retourne true

$i = 12; // La fonction is_int($i) retourne la valeur true

$r = 16.34; // La fonction is_float($r) retourne la valeur true


Les constantes, variables et méthodes de cette classe sont immédiatement accessibles sans qu’il soit nécessaire d’utiliser une instruction import. La déclaration suivante est implicite :

import java.lang.*;

Le constructeur

Le constructeur permettant de définir un objet String peut prendre de nombreuses formes :

public String();
public String(String value);
public String(char value[]);
public String(char value[],int offset, int count);
public String(byte ascii[],int hibyte, int offset, int count);
public String(byte ascii[], int hibyte);
public String(byte bytes[], int offset, int length, String enc);
public String(byte bytes[], String enc);
public String(byte bytes[], int offset, int length);
public String(byte bytes[]);

Examinons quelques-unes de ces variantes.

La première forme permet de construire un objet String vide :

public String();

Exemple :

String S = new String("");

ou encore :

String S = "";

Comme vous le remarquez, le mot clé new n’est pas obligatoire pour définir un objet String. Cette particularité de la classe String est bien pratique, car elle allège sensiblement l’écriture. Mais attention, les “mauvaises” habitudes sont très vite prises : la définition d’un objet appartenant à une autre classe que String passe obligatoirement par l’opérateur new.

La deuxième forme permet d’affecter une valeur à un nouvel objet String :

public String(String value);

Exemple :

String S = String("Ceci est un objet String");

ou encore :

String S = "Ceci est un objet String";

La troisième forme utilise le contenu d’un tableau de caractères pour construire un nouvel objet String :

public String(char value[]);

Exemple :

char C[] = {'a', 'b', 'c', 'd', 'e', 'f'};
String S = new String(C);

La quatrième forme permet d’affecter une partie d’un tableau de caractères à un nouvel objet String. Le premier paramètre représente le nom du tableau de caractères ; le deuxième la position du premier caractère à affecter à l’objet String, et le troisième le nombre de caractères consécutifs à affecter :

public String(char value[],int offset, int count);

Exemple :

char C[] = {'a', 'b', 'c', 'd', 'e', 'f'};
String S = new String(C,2,3);

A ce niveau, l’objet S a pour valeur “cde”.

La cinquième forme construit un nouvel objet String à partir d’un tableau de bytes. Le premier paramètre représente le tableau de bytes. Le deuxième paramètre (généralement égal à 0) correspond au poids fort des valeurs Unicode du tableau. Les troisième et quatrième paramètres représentent la position du premier élément du tableau et le nombre d’éléments du tableau à affecter à l’objet String :

public String(byte ascii[],int hibyte, int offset, int count);

Exemple :

byte C[] = {'a', 'b', 'c', 'd', 'e', 'f'};
String S = new String(C,0,2,3);

A ce niveau, l’objet S a pour valeur “cde”.

Enfin, la sixième forme construit un nouvel objet String à partir d’un tableau de bytes. Le premier paramètre représente le tableau de bytes. Le deuxième paramètre (généralement égal à 0) correspond au poids fort des valeurs Unicode du tableau :

public String(byte ascii[], int hibyte);

Exemple :

byte C[] = {'a', 'b', 'c', 'd', 'e', 'f'};
String S = new String(C,0);

Les méthodes

charAt()

Cette méthode renvoie le caractère qui occupe la position spécifiée dans l’argument. Le premier caractère occupe la position 0 et le dernier la position length() – 1 :

public char charAt(int index)

Exemple :

public class Test {
  public static void main (String args[]) throws java.io.IOException
  {
    String S = "String";
    int i;
    for (i=0; i<=S.length() - 1; i++)
      System.out.println("Le caractère en position " + i + " est " + S.charAt(i));
  }
}

Après avoir affecté une chaîne à l’objet String S :

String S = "String";

Une boucle for utilise la méthode charAt() pour extraire tous les caractères de l’objet S :

for (i=0; i<=S.length() - 1; i++)
  System.out.println("Le caractère en position " + i + " est " + S.charAt(i));

Voici le résultat :
 

 
compareTo()

La méthode compareTo() compare deux objets String. Elle renvoie :

  • Un entier nul si les deux chaînes sont égales.
  • Un entier positif si la première chaîne est “supérieure” à la deuxième.
  • Un entier négatif si la première chaîne est “inférieure” à la deuxième :

public int compareTo(String anotherString)

Exemple :

public class Test {
  public static void main (String args[]) throws java.io.IOException
  {
    String S1, S2;

    System.out.println("Entrez une chaîne : ");
    S1 = Lit();
    System.out.println("Entrez une autre chaîne : ");
    S2 = Lit();
    if (S1.compareTo(S2) == 0)
      System.out.println("Les deux chaînes sont identiques");
    else
      System.out.println("Les deux chaînes sont différentes");
  }
  public static String Lit() throws java.io.IOException
  {
    String S = "";
    char C;
    while ((C=(char)System.in.read()) != '\r')
    {
      S = S + C;
    }
    C=(char)System.in.read();
    return S;
  }
}

Après avoir lu et mémorisé les deux chaînes entrées au clavier :

System.out.println("Entrez une chaîne : ");
S1 = Lit();
System.out.println("Entrez une autre chaîne : ");
S2 = Lit();

le programme utilise la méthode compareTo() pour comparer ces deux chaînes. Un message ou un autre est affiché en fonction de leur égalité :

if (S1.compareTo(S2) == 0)
  System.out.println("Les deux chaînes sont identiques");
else
  System.out.println("Les deux chaînes sont différentes");

concat()

La méthode concat() concatène la chaîne spécifiée dans les parenthèses à la suite de la chaîne en préfixe :

public String concat(String str)

Exemple :

public class Test {
  public static void main (String args[]) throws java.io.IOException {
    String S1, S2;
    System.out.println("Entrez une chaîne : ");
    S1 = Lit();
    System.out.println("Entrez une autre chaîne : ");
    S2 = Lit();
    System.out.println("La concaténation de ces deux chaînes est : " + S1.concat(S2));
  }
  public static String Lit() throws java.io.IOException {
    String S = "";
    char C;
    while ((C=(char)System.in.read()) != '\r') {
      S = S + C;
    }
    C=(char)System.in.read();
    return S;
  }
}

Le premier bloc d’instructions lit deux chaînes et les place dans les objets S1 et S2.

System.out.println("Entrez une chaîne : ");
S1 = Lit();
System.out.println("Entrez une autre chaîne : ");
S2 = Lit();

Puis les valeurs contenues dans ces deux objets sont concaténées à l’aide de la méthode concat() et affichées sur l’écran :

System.out.println("La concaténation de ces deux chaînes est : " + S1.concat(S2));

Remarque

Les deux instructions suivantes sont équivalentes :

System.out.println(S1.concat(S2));
System.out.println(S1 + S2);

copyValueOf()

La méthode copyValueOf() copie une partie ou la totalité d’un tableau de caractères dans un objet String :

public static String copyValueOf(char data[], int offset, int count)
public static String copyValueOf(char data[])

Exemple :

public class Test {
  public static void main (String args[]) throws java.io.IOException {
    char C[] = {'a', 'b', 'c', 'd', 'e', 'f'};
    String S = String.copyValueOf(C, 2, 3);
    System.out.println(S);
  }
}

Dans cet exemple, le premier caractère copié occupe la position 2. Trois caractères sont copiés dans l’objet S. L’instruction print affiche donc “cde”.

endsWith()

La méthode endsWith() renvoie la valeur booléenne true si la chaîne se termine par l’argument et une valeur false dans le cas contraire :

public boolean endsWith(String suffix)

Exemple :

public class Test {
  public static void main (String args[]) throws java.io.IOException {
    String S1, S2;

    System.out.println("Entrez une chaîne : ");
    S1 = Lit();

    if (S1.endsWith("e"))
      System.out.println("Cette chaîne se termine par la lettre e.");
    else
      System.out.println("Cette chaîne ne se termine pas par la lettre e.");
  }

  public static String Lit() throws java.io.IOException {
    String S = "";
    char C;
    while ((C=(char)System.in.read()) != '\r') {
      S = S + C;
    }
    C=(char)System.in.read();
    return S;
  }
}

Le premier bloc d’instructions lit une chaîne de caractères et la stocke dans la variable S1 :

System.out.println("Entrez une chaîne : ");
S1 = Lit();

Le deuxième bloc d’instructions affiche un texte ou un autre selon que la chaîne entrée se termine ou que pas par la lettre “e” :

if (S1.endsWith("e"))
  System.out.println("Cette chaîne se termine par la lettre e.");
else
  System.out.println("Cette chaîne ne se termine pas par la lettre e.");

equals()

La méthode equals() compare la valeur de deux objets String. Elle renvoie la valeur true si les deux valeurs sont identiques et la valeur false dans le cas contraire :

public boolean equals(Object anObject)

Exemple :

Supposons que S1 et S2 soient deux objets String initialisés. L’instruction ci-après affiche un texte ou un autre selon que ces deux chaînes sont égales ou différentes :

if (S1.equals(S2))
  System.out.println("Les deux chaînes sont identiques");
else
  System.out.println("Les deux chaînes sont différentes");

equalsIgnoreCase()

La méthode equalsIgnoreCase() compare la valeur de deux objets String sans différencier les majuscules des minuscules. Elle renvoie la valeur true si les deux valeurs sont “identiques” et la valeur false dans le cas contraire :

public boolean equalsIgnoreCase(String anotherString)

Exemple :

Supposons que S1 et S2 soient deux objets String initialisés. L’instruction ci-après affiche un texte ou un autre selon que ces deux chaînes sont égales ou différentes :

if (S1.equalsIgnoreCase(S2))
  System.out.println("Les deux chaînes sont identiques");
else
  System.out.println("Les deux chaînes sont différentes");

Si, par exemple, S1=”AZERTY” et S2=”AZErTY”, la méthode equalsIgnoreCase() renvoie la valeur true car les deux chaînes sont considérées comme identiques.

getChars()

La méthode getChars() copie un ou plusieurs caractères d’un objet String dans un tableau de char :

public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin)
  • srcBegin est la position du premier caractère dans l’objet String ;
  • srcEnd est la position du dernier caractère dans l’objet String ;
  • dst[] est le tableau de char destination ;
  • dstBegin est la position du premier caractère dans le tableau destination.

Exemple :

public class Test {
  public static void main (String args[]) throws java.io.IOException {
    char C[] = {'a', 'b', 'c', 'd', 'e', 'f'};
    String S = "ABCDEF";

    System.out.println("Au départ, le tableau C contient les caractères a, b, c, d, e et f");
    System.out.println("et la chaîne S les caractères ABCDEF");
    S.getChars(1,3,C,1);
    System.out.println("L'instruction S.getChars(1,3,C,1) modifie le tableau C comme suit :");
    String S2 = new String(C);
    System.out.println(S2);
  }
}

Les deux premières instructions définissent et initialisent un tableau de bytes et un objet String :

byte C[] = {'a', 'b', 'c', 'd', 'e', 'f'};
String S = "ABCDEF";

Après avoir affiché le contenu du tableau C et de l’objet S :

System.out.println("Au départ, le tableau C contient les caractères a, b, c, d, e et f");
System.out.println("et la chaîne S les caractères ABCDEF");

la méthode getChars() est utilisée pour copier les caractères 1 à 3 de l’objet S dans le tableau C :

S.getChars(1,3,C,1);

Le résultat est alors affiché. Comme vous le voyez, le tableau de chars C a été converti en un objet String pour faciliter son affichage :

System.out.println("L'instruction S.getChars(1,3,C,1) modifie le tableau C comme suit :");
String S2 = new String(C);
System.out.println(S2);

Voici le résultat :
 

 
hashCode()

Cette méthode retourne le hashcode (chaque objet Java possède un hashcode qui lui est propre) de l’objet sur lequel elle est appliquée :

public int hashCode();

indexOf()

La méthode indexOf() permet de localiser un caractère ou une sous-chaîne dans un objet String. Elle renvoie la valeur -1 si le caractère ou la chaîne recherchée ne fait pas partie de l’objet String. Cette méthode admet quatre syntaxes :

public int indexOf(int ch)
public int indexOf(int ch, int fromIndex)
public int indexOf(String str)
public int indexOf(String str, int fromIndex)

La première syntaxe renvoie la position de la première occurrence de ch dans l’objet String :

public int indexOf(int ch)

La deuxième syntaxe renvoie la position de la première occurrence de ch dans l’objet String, à partir de la position fromIndex :

public int indexOf(int ch, int fromIndex)

La troisième syntaxe renvoie la position de la première occurrence de la sous-chaîne str dans l’objet String :

public int indexOf(String str)

Enfin, la quatrième syntaxe renvoie la position de la première occurrence de la sous-chaîne str dans l’objet String, à partir de la position fromIndex :

public int indexOf(String str, int fromIndex)

Exemple :

public class Test {
  public static void main (String args[]) throws java.io.IOException {
    System.out.println("Entrez une chaîne : ");
    String S = Lit();
    System.out.println("Entrez un caractère : ");
    char Ch = (char) System.in.read();
    int Position = S.indexOf(Ch);
    if (Position == -1)
      System.out.println("Le caractère ne fait pas partie de la chaîne.");
    else
      System.out.println("Le premier caractère " + Ch + " se trouve en position " + Position);
  }
  public static String Lit() throws java.io.IOException {
    String S = "";
    char C;
    while ((C=(char)System.in.read()) != '\r') {
      S = S + C;
    }
    C=(char)System.in.read();
    return S;
  }
}

Après avoir saisi une chaîne de caractères :

System.out.println("Entrez une chaîne : ");
String S = Lit();

et un caractère unique :

System.out.println("Entrez un caractère : ");
char Ch = (char) System.in.read();

le programme recherche la première position du caractère dans la chaîne à l’aide de la méthode indexOf(). Le résultat est stocké dans la variable int Resultat :

int Position = S.indexOf(Ch);

Le message qui en découle est fonction de la valeur de Resultat. Si Resultat vaut -1, le caractère n’a pas été trouvé :

if (Position == -1)
  System.out.println("Le caractère ne fait pas partie de la chaîne.");

Dans le cas contraire, la position de sa première occurrence est affichée :

else
  System.out.println("Le premier caractère " + Ch + " se trouve en position " + Position);

intern()

La méthode intern() renvoie un objet String qui occupe la même place mémoire que celui sur lequel il est appliqué :

public String intern()

Exemple :

String S1 = "coucou";
String S2 = S1.intern();

lastIndexOf()

La méthode lastindexOf() permet de localiser la dernière position d’un caractère ou une sous-chaîne dans un objet String. Elle renvoie la valeur -1 si le caractère ou la chaîne recherchée ne fait pas partie de l’objet String. Cette méthode admet quatre syntaxes :

public int lastIndexOf(int ch)
public int lastIndexOf(int ch, int fromIndex)
public int lastIndexOf(String str)
public int lastIndexOf(String str, int fromIndex)

La première syntaxe renvoie la position de la dernière occurrence de ch dans l’objet String :

public int lastIndexOf(int ch)

La deuxième syntaxe renvoie la position de la dernière occurrence de ch dans l’objet String, à partir de la position fromIndex :

public int lastIndexOf(int ch, int fromIndex)

La troisième syntaxe renvoie la position de la dernière occurrence de la sous-chaîne str dans l’objet String :

public int lastIndexOf(String str)

Enfin, la quatrième syntaxe renvoie la position de la dernière occurrence de la sous-chaîne str dans l’objet String, à partir de la position fromIndex :

public int lastIndexOf(String str, int fromIndex)

Exemple :

public class Test {
  public static void main (String args[]) throws java.io.IOException {
    System.out.println("Entrez une chaîne : ");
    String S = Lit();
    System.out.println("Entrez un caractère : ");
    char Ch = (char) System.in.read();
    int Position = S.lastIndexOf(Ch);
    if (Position == -1)
      System.out.println("Le caractère ne fait pas partie de la chaîne.");
    else
      System.out.println("Le dernier caractère " + Ch + " se trouve en position " + Position);
  }
  public static String Lit() throws java.io.IOException {
    String S = "";
    char C;
    while ((C=(char)System.in.read()) != '\r') {
      S = S + C;
    }
    C=(char)System.in.read();
    return S;
  }
}

Après avoir saisi une chaîne de caractères :

System.out.println("Entrez une chaîne : ");
String S = Lit();

Et un caractère unique :

System.out.println("Entrez un caractère : ");
char Ch = (char) System.in.read();

le programme recherche la dernière position du caractère dans la chaîne à l’aide de la méthode lastIndexOf(). Le résultat est stocké dans la variable int Resultat :

int Position = S.lastIndexOf(Ch);

Le message qui en découle est fonction de la valeur de Resultat. Si Resultat vaut -1, le caractère n’a pas été trouvé :

if (Position == -1)
  System.out.println("Le caractère ne fait pas partie de la chaîne.");

Dans le cas contraire, la position de sa dernière occurrence est affichée :

else
  System.out.println("Le dernier caractère " + Ch + " se trouve en position " + Position);

length()

La méthode length() renvoie sous la forme d’un int la longueur de la chaîne sur laquelle elle est appliquée :

public int length()

regionMatches()

La méthode regionMatches() détermine si deux portions de chaînes sont identiques. Dans l’affirmative, elle renvoie la valeur true. Cette méthode admet deux syntaxes :

public boolean regionMatches(int toffset, String other, int ooffset, int len)
public boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)

Dans la première syntaxe :

  • toffset représente la position du premier caractère à comparer dans le premier objet String (en préfixe).
  • other représente le deuxième objet chaîne à comparer.
  • oofset représente la position du premier caractère à comparer dans le deuxième objet chaîne.
  • len est le nombre de caractères consécutifs à comparer.

La deuxième syntaxe se différencie de la première par la présence du paramètre booléen ignoreCase. Si ce paramètre vaut true, les minuscules et les majuscules sont confondues dans la comparaison.

Exemple :

public class Test {
  public static void main (String args[]) throws java.io.IOException
  {
    String S1 = "Ceci EST une Chaîne";
    String S2 = "Ceci est une autre chaîne";
    System.out.println("S1 = " + S1);
    System.out.println("S2 = " + S2);
    System.out.println("Comparaison des 11 premiers caractères de S1 et S2 (ignoreCase = true) : " + S1.regionMatches(true, 0, S2, 0, 11) );
    System.out.println("Comparaison des caractères 5 à 7 de S1 et S2 (ignoreCase = false) : " + S1.regionMatches(false, 5, S2, 5, 3) );
    System.out.println("Comparaison caractères 13 à 16 de S1 et S2 (ignoreCase non utilisé) : " + S1.regionMatches(13, S2, 13, 4) );
  }
}

Ce programme donne trois exemples d’utilisation de la méthode regionMatches() et montre l’influence du paramètre ignoreCase.

La première comparaison porte sur les 11 premiers caractères des chaînes S1 et S2. Le paramètre ignoreCase étant initialisé à true, les deux sous-chaînes sont considérées comme égales :

"Ceci EST un" = "Ceci est un"

La deuxième comparaison porte sur le mot “EST” qui occupe les positions 5 à 7 dans les deux chaînes. Le paramètre ignoreCase étant initialisé à false, les deux sous-chaînes sont considérées comme différentes :

"EST" <> "est"

Enfin, la troisième instruction compare des chaînes manifestement différentes :

"Chaî" <> "autr"

Voici le résultat :
 

 
replace()

La méthode replace() effectue un remplacement systématique de tous les caractères identiques au premier paramètre par le second paramètre :

public String replace(char oldChar, char newChar)

Exemple :

public class Test {
  public static void main (String args[]) throws java.io.IOException
  {
    String S = "Ceci est une Chaîne";
    System.out.println("La chaîne S avant remplacement : " + S);
    S = S.replace('e','E');
    System.out.println("La chaîne S après remplacement : " + S);
  }
}

Le premier bloc d’instructions définit l’objet String S et l’affiche :

String S = "Ceci est une Chaîne";
System.out.println("La chaîne S avant remplacement : " + S);

Le deuxième bloc d’instructions remplace tous les “e” par des “E” dans l’objet S et affiche le résultat :

S = S.replace('e','E');
System.out.println("La chaîne S après remplacement : " + S);

Voici le résultat :
 

 
startsWith()

La méthode starsWith() renvoie la valeur booléenne true si la chaîne commence par le premier argument et une valeur false dans le cas contraire. Cette méthode admet deux syntaxes. Dans la deuxième, on précise la position du début de la comparaison :

public boolean startsWith(String preffix)
public boolean startsWith(String preffix, int toffset)

substring()

La méthode substring() permet d’extraire une sous-chaîne de la chaîne spécifiée en préfixe. Elle admet deux syntaxes.

Dans la première syntaxe, la sous-chaîne s’étend de la position beginIndex jusqu’à la fin de la chaîne :

public String substring(int beginIndex)

Dans la deuxième syntaxe, la sous-chaîne s’étend de la position beginIndex jusqu’à la position endIndex-1 :

public String substring(int beginIndex, int endIndex)

toCharArray()

La méthode toCharArray() convertit un objet String en un tableau de caractères :

public char[] toCharArray()

Exemple :

La première instruction définit et initialise un objet String. La deuxième le stocke dans le tableau de caractères ch :

String S = "Ceci est un objet String";
char ch [] = S.toCharArray();

toLowerCase()

La méthode toLowerCase() transforme en minuscules le contenu de l’objet String sur lequel elle est appliquée :

public String toLowerCase()

toUpperCase()

La méthode toUpperCase() transforme en majuscules le contenu de l’objet String sur lequel elle est appliquée :

public String toUpperCase()

trim()

La méthode trim() supprime les espaces de début et de fin de l’objet String qui lui est passé :

public String trim()

valueOf()

La méthode valueOf() convertit un booléen, un char, un tableau de char (entier ou une portion), un int, un long, un float ou un double en un objet String :

public static String valueOf(boolean b)
public static String valueOf(char c)
public static String valueOf(char data[])
public static String valueOf(char data[], int offset, int count)
public static String valueOf(int i)
public static String valueOf(long l)
public static String valueOf(float f)
public static String valueOf(double d)

Comme nous l’avons vu précédemment, Java implémente un certain nombre de types simples : boolean, byte, char, double, float, int, long et short. Pour compliquer les choses – disons plutôt pour faciliter la vie des programmeurs C – des types composites sont également disponibles dans le langage Java : Boolean, Character, Double, Float, Integer, Long, Number et String.

Si les types simples s’appliquent à des variables, les types composites concernent uniquement des objets.

Par exemple, pour définir une variable int, vous utiliserez l’instruction :

int i;

Alors que pour définir un objet Integer, vous utiliserez l’instruction :

Integer I;

Si a priori, il semble que peu de différences existent entre ces deux types de données, les lignes suivantes auront tôt fait de vous convaincre du contraire.

Pour affecter une valeur à une variable simple, il suffit d’utiliser le signe “=”, par exemple :

int i;
i = 3;

ou encore :

int i = 3;

Pour initialiser un objet composite, il faut utiliser un constructeur. Ce dernier porte par définition le même nom que la classe dont il dépend et commence toujours par une lettre majuscule.

Par exemple, l’instruction ci-après définit un objet Integer et lui affecte la valeur 10 :

Integer I = new Integer(10);

Ou encore, l’instruction suivante définit un objet String et lui affecte la chaîne “Ceci est un objet String” :

String S = new String("Ceci est un objet String");

Les différences vont beaucoup plus loin. Les objets composites sont accessibles par l’intermédiaire de méthodes alors que les variables simples sont manipulées à l’aide des opérateurs et mots clés du langage Java.

Dans la section suivante, nous allons présenter les variables et méthodes rattachées aux types composites Boolean, Character, Double, Float, Integer, Long, Number et String. Après leur lecture, vous serez en mesure de choisir qui d’une variable simple ou d’un objet est le mieux adapté à la résolution d’un problème donné.


Les codes ASCII

Le petit programme ci-après affiche les caractères dont le code ASCII est compris entre 32 et 256 :

public class ASCII{

  public static void main (String args[]) throws java.io.IOException {
    // Illustration des caractères ASCII
    int i, j;
    char ch;

    System.out.println("Les caractères ASCII de 32 à 255");
    for (i=32; i<256; i++) {
      for (j=0; j<11; j++) {
        if ((i+j)<100)
          System.out.print("0");
        ch = (char) (i+j);
        if ((i+j)<257)
          System.out.print(i+j + " " + ch + "  ");
      }
      System.out.println("");
      i=i+10;
    }
  }
}

Chaînes de caractères

Pour manipuler des chaînes de caractères, vous utiliserez des objets non pas de type String, mais de classe String. Comme nous le verrons dans la suite de la formation, la syntaxe à utiliser pour ces différents objets est très similaire. Bien que les possibilités offertes par la classe String soient la plupart du temps suffisantes, vous pouvez également utiliser un tableau de char pour manipuler vos chaînes de caractères.

A titre d’exemple, l’instruction ci-après définit un objet String et lui affecte une valeur :

String s = new String("Ceci est une chaîne");

Pour faciliter l’écriture, on préfèrera cette syntaxe :

String s = "Ceci est une chaîne";

Les variables de classe String peuvent également contenir des caractères d’échappement :

Code Caractère Equivalent hexadécimal
\b Backspace \u0008
\t Tabulation horizontale \u0009
\n Line feed \u000a
\f Form feed \u000c
\r Carriage return \u000d
\” Guillemet \u0022
\’ Apostrophe \u0027
\\ Antislash \u005c
\xdd Valeur hexadécimale  
\ddd Valeur octale  
\u00xx Valeur hexadécimale représentant un caractère Unicode (où xx est compris entre 00 et ff)  

Exemples :

String c1 = "\f";
String c2 = "\u0084";

Types de données prédéfinis

Les types de données prédéfinis en Java ne sont pas très nombreux. Ils permettent de manipuler des nombres entiers (byte, short, int, long), des nombres réels (float, double), des booléens (boolean) et des caractères (char). Par extension, vous pouvez également utiliser la classe String pour manipuler facilement des chaînes de caractères.

Les divers types de données utilisables en Java vont être passés en revue dans les sections suivantes.

Nombres entiers

Selon la taille des nombres à manipuler, vous utiliserez le format byte, short, int ou long :

  • Les entiers byte sont codés sur 8 bits. Ils permettent de manipuler des nombres compris entre -2^7 et (2^7)- 1, c’est-à-dire entre -128 et 127.
  • Les entiers short sont codés sur 16 bits. Ils permettent de manipuler des nombres compris entre -2^15 et (2^15)-1, c’est-à-dire entre -32768 et 32767.
  • Les entiers int sont codés sur 32 bits. Ils permettent de manipuler des nombres compris entre -2^31 et (2^31)-1, c’est-à-dire entre -2147483648 et 2147483647.
  • Enfin, les entiers long sont codés sur 64 bits. Ils permettent de manipuler des nombres compris entre -2^63 et 2^63, c’est-à-dire entre -9223372036854775808 et 9223372036854775807.

Exemples :

Les nombres entiers peuvent être exprimés en décimal (base 10), en hexadécimal (base 16) ou en octal (base 8) :

byte NombreDécimal = 127;       // Un nombre entier exprimé en décimal
int NombreHexadécimal = 0x5ec;  // Un nombre entier exprimé en hexadécimal
long NombreOctal = 0346;        // Un nombre entier exprimé en octal

Nombres réels

Les nombres réels sont composés d’une partie entière suivie d’un point, d’une partie décimale, de la lettre e (ou E) et d’un exposant, éventuellement précédé d’un signe + ou -.

Voici quelques exemples de nombres réels :

325.707
3.25707E2
.325707E3
-45.567E-5

Le langage Java manipule deux types de réels :

  • Les réels float sont codés en simple précision sur 32 bits (1.40239846e-45 à 3.40282347e38).
  • Les réels double sont codés en double précision sur 64 bits (4.94065645841246544e-324 à 1.79769313486231570e308).

Vous pouvez spécifier le type d’une variable réelle pendant sa création en utilisant les mots clés double et float :

double d = 34.56567;
float f = 123.56;

Attention :

La seconde instruction est incorrecte : Lorsque Java rencontre un point décimal dans une affectation, il suppose qu’il s’agit d’un réel double. En affectant un nombre contenant un point décimal à une variable float, vous obtiendrez un message d’erreur vous indiquant une incompatibilité de type. Pour résoudre ce problème, vous utiliserez l’une des deux syntaxes suivantes :

float f = (float)123.56;
float f = 123.56f;
La lettre "f" à la fin de la seconde instruction indique que la donnée est de type float et non double. De la même façon, vous pouvez utiliser le suffixe "d" pour affecter une valeur double à une variable :
double d = 145.56565d;

Remarque

Les suffixes f et d peuvent être indifféremment utilisés en lettres minuscules ou majuscules.

Booléens

Ils peuvent prendre la valeur true ou la valeur false. Si vous le souhaitez, il est également possible d’utiliser (comme dans de nombreux autres langages) un nombre non nul pour représenter la valeur true et le nombre 0 pour représenter la valeur false.

Dans l’exemple suivant, les instructions définies entre les deux accolades seront exécutées. En effet, la variable Valeur étant non nulle, sa valeur est interprétée comme true.

Valeur = 4;
if Valeur then {
  ...
}

Type char

Une variable de type char peut contenir un (et un seul !) caractère. Java utilise le jeu de caractères 16 bits Unicode qui contient quelque 65 000 caractères! Il est donc possible de manipuler des caractères spécifiques à la langue française (à, é, è, ç, etc.) dans les variables char… et par extension dans les chaînes String.

A titre d’exemple, les deux affectations ci-après sont correctes :

char c1 = 'é';
char c2 = '1';

Par contre, cette troisième affectation produira une erreur lorsqu’elle sera exécutée :

char c3 = 'er';