Médiaforma

All posts tagged classe

Cliquez ici pour accéder au pack eBook+vidéos HTML5, CSS3, JavaScript

Dans la section précédente, vous avez vu qu’une classe pouvait être appliquée à plusieurs balises en affectant le nom de la classe à l’attribut class des balises concernées. Ici, je vais vous montrer comment restreindre le champ d’action d’une classe.

Le document HTML est des plus classiques. Il fait référence à la feuille de styles externe styles3.css. Le corps du document contient un titre de niveau 2 et de classe rouge, un paragraphe de classe rouge et un simple texte sans classe.

Maintenant, nous allons définir une classe rouge spécifique à la balise <h2> et une autre classe rouge spécifique à la balise <p>. Pour cela, il suffit de faire précéder le point décimal de la classe par le nom de la balise concernée.

C’est ainsi que nous définissons la classe p.rouge qui sera dédiée à la balise <p> et la classe h2.rouge qui sera dédiée à la balise <h2>. Pour bien montrer que les caractéristiques de ces deux classes sont différentes, la propriété font-family (c’est-à-dire la police) de la classe p.rouge est initialisée avec la valeur Courrier New et celle de la classe h2.rouge avec la valeur fantasy. Remarquez au passage les guillemets qui entourent le nom de la police dans la classe p.rouge. Ils sont nécessaires parce que le nom de la police contient un espace. Enfin, la taille des caractères de classe h2.rouge est fixée à 30 pixels avec la propriété font-size.

Affichons ce document dans un navigateur.  Comme vous pouvez le voir, la classe rouge est bien différente lorsqu’elle est appliquée aux balises <h2> et <p>.


Cliquez ici pour accéder au pack eBook+vidéos HTML5, CSS3, JavaScript

Une classe CSS permet de modifier les caractéristiques d’une balise en fonction de son attribut class.

Pour mieux comprendre de quoi il est question, nous allons raisonner sur un exemple. Trois balises <h2> sont ajoutées au document HTML. La première a un attribut class initialisé à rouge, la deuxième a un attribut class initialisé à noir et la troisième a un attribut class initialisé à vert. Plus simplement, on dira que la première balise <h2> est de classe rouge, la deuxième de classe noir et la troisième de classe vert.

Affichons le document dans un navigateur. Les trois titres H2 apparaissent en noir. Si vous trouvez cela étrange, interrogez-vous : est-ce qu’il ne manque pas un peu de code CSS pour obtenir les couleurs demandées ? Bien sûr que si : il faut définir les classes rouge, noir et vert dans le fichier styles2.css (puisque c’est ce fichier qui est spécifié dans la balise <link>).

Voici la feuille de styles à utiliser :

Comme vous le voyez, la définition d’une classe n’a rien d’insurmontable. Pour cela, il suffit de faire précéder le nom de la classe d’un point décimal, de le faire suivre d’un espace et d’accolades ouvrante et fermante et de préciser la ou les propriétés à modifier entre les accolades.

Ici :

  • la classe noir affecte la valeur black à la propriété color ;
  • la classe rouge affecte la valeur red à la propriété color ;
  • la classe vert affecte la valeur green à la propriété color.

Affichons à nouveau le document dans le navigateur. Cette fois-ci l’effet recherché est bien obtenu :

Là où les classes deviennent vraiment magiques, c’est quand vous les utilisez dans plusieurs balises. Ainsi par exemple, vous pouvez très bien utiliser les classes noir, rouge et vert dans des balises <p>, <td> ou n’importe quelle autre balise qui concerne des éléments textuels.

Ici par exemple, nous définissons un tableau constitué de deux cellules. La première contient un texte affiché en vert via la balise <td> de classe vert et la deuxième un texte affiché en rouge via la balise <td> de classe rouge :

Affichons ce document dans un navigateur. Intéressant non ?


Pour instancier une classe (c’est-à-dire pour créer un objet à partir d’une classe), vous devez :

    1. Insérer le code de la classe à l’aide d’une instruction include_once :
 include_once(nom);

nom est le nom du fichier dans lequel a été définie la classe.

 

  • Créer un objet avec l’instruction new :

 

 $objet = new classe();

objet est le nom de l’objet créé et classe le nom de la classe à utiliser comme modèle.

 

Pour accéder à une méthode ou une propriété publique, utilisez la syntaxe suivante :

$this -> nom;

Où nom est le nom de la méthode ou de la propriété publique à accéder.

Vous pouvez par exemple :

  • Affecter une valeur à une propriété publique :
     $this -> nomPropriete = 10;
  • Afficher la valeur d’une propriété publique :
     echo $this -> nomPropriete;
  • Lancer une fonction publique :
     $this -> nomFonction();
  • Lancer une fonction publique en lui passant des paramètres :
     $this -> nomFonction("a", 15, "x");
  • Afficher la valeur retournée par une fonction publique :
     echo $this -> nomFonction();

Nous allons maintenant nous intéresser à une classe qui contient de nombreuses méthodes très intéressantes au niveau du calcul entier et réel : la classe Math. Les constantes, variables et méthodes de cette classe sont immédiatement accessibles sans qu’il soit nécessaire d’utiliser une instruction import, car la déclaration suivante est implicite :

import java.lang.*;

Les variables

E représente une approximation de la base des logarithmes népériens : 2.7182818284590452354f.

PI représente une approximation du nombre irrationnel PI : 3.14159265358979323846f.

Les méthodes

IEEEremainder()

La méthode IEEEremainder() retourne le reste de la division du premier argument par le second selon la norme IEEE 754 :

public static double IEEEremainder(double f1, double f2)

Exemple :

public class Test {
  public static void main (String args[]) throws java.io.IOException {
    double r1, r2;
    char ch;
    String Interm;
    System.out.println("Entrez le dividende : ");
    Interm = Lit();
    r1=Double.valueOf(Interm).doubleValue();
    System.out.println("Entrez le diviseur : ");
    Interm = Lit();
    r2=Double.valueOf(Interm).doubleValue();
    System.out.println("Selon la norme IEE 754,");
    System.out.println("le reste de la division de " + r1 + " par " + r2 + " est " + Math.IEEEremainder(r1, r2));
  }
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 le dividende et le diviseur et stocke ces deux valeurs dans les variables r1 et r2.

System.out.println("Entrez le dividende : ");
...
r2=Double.valueOf(Interm).doubleValue();

Le deuxième bloc d’instructions utilise la méthode IEEEremainder() pour calculer et afficher le reste de la division du premier nombre par le second, selon la norme IEE 754 :

System.out.println("Selon la norme IEE 754,");
System.out.println("le reste de la division de " + r1 + " par " + r2 + " est " + Math.IEEEremainder(r1, r2));

abs()

La méthode abs() renvoie la valeur absolue de la valeur int, long, float ou double qui lui est passée. Le type de la valeur retournée est le même que celui de la valeur passée :

public static int abs(int a)
public static long abs(long a)
public static float abs(float a)
public static double abs(double a)

acos()

La méthode acos() retourne sous la forme d’un double l’arc cosinus (en radians) de la mesure d’angle qui lui est passée :

public static double acos(double a)

asin()

La méthode asin() retourne sous la forme d’un double l’arc sinus (en radians) de la mesure d’angle qui lui est passée :

public static double asin(double a)

atan()

La méthode atan() retourne sous la forme d’un double l’arc tangente (en radians) de la mesure d’angle qui lui est passée :

public static double atan(double a)

atan2()

La méthode atan2() renvoie la composante théta (r, théta) des coordonnées rectangulaires qui lui sont passées :

public static double atan2(double a, double b)

ceil()

Cette fonction retourne sous la forme d’un double l’entier supérieur ou égal à la valeur spécifiée :

public static double ceil(double a)

cos()

La méthode cos() renvoie sous la forme d’un double le cosinus de l’angle (en radians) passé en argument :

public static double cos(double a)

exp()

La méthode exp() renvoie sous la forme d’un double l’exponentielle de son argument :

public static double exp(double a)

floor()

La méthode floor() renvoie sous la forme d’un double l’entier inférieur ou égal à la valeur spécifiée :

public static double floor(double a)

log()

La méthode log() renvoie sous la forme d’un double le logarithme népérien du nombre passé en argument.

public static double log(double a) throws ArithmeticException

max()

La méthode max() renvoie le plus grand de ses deux arguments :

public static int max(int a, int b)
public static long max(long a, long b)
public static float max(float a, float b)
public static double max(double a, double b)

min()

La méthode min() renvoie le plus petit de ses deux arguments :

public static int min(int a, int b)
public static long min(long a, long b)
public static float min(float a, float b)
public static double min(double a, double b)

pow()

La méthode pow() retourne sous la forme d’un double la mise à la puissance du premier argument par le second :

public static double pow(double a, double b) throws ArithmeticException

random()

La méthode random() retourne un double pseudo-aléatoire compris entre 0.0 et 1.0 :

public static synchronized double random()

Exemple :

public class Test {
  public static void main (String args[]) throws java.io.IOException {
    int i;
    for (i=0; i<10; i++) {
      System.out.println(Math.random());
    }
  }
}

Ce programme consiste en une boucle for exécutée dix fois qui appelle la méthode random() et affiche le résultat.

Remarque

La classe java.util.Random donne accès à un générateur de nombres pseudo-aléatoires qui est une variante intéressante de la méthode Math.random(). Dans la classe Random, plusieurs méthodes peuvent être utilisées pour générer des nombres aléatoires :

public double nextDouble();
public float nextFloat();
public synchronized double nextGaussian();
public int nextInt();
public long nextLong();

Le nom des méthodes est très parlant : nextDouble() renvoie un double, nextFloat() un float, nextInt() un int et nextLong() un long. Quant à la méthode nextGaussian(), elle renvoie des valeurs “double” qui suivent une distribution gaussienne centrée sur la valeur 0 et d’amplitude 1 (c’est-à-dire entre -1 et 1).

rint()

La méthode rint() renvoie sous la forme d’un double la valeur arrondie de son argument double :

public static double rint(double a)

round()

La méthode round() renvoie sous la forme d’un int/d’un long la valeur arrondie de son argument float/double. Le calcul est effectué en ajoutant la valeur 0.5 à l’argument et en prenant la valeur entière inférieure ou égale au nombre obtenu :

public static int round(float a)
public static long round(double a)

sin()

La méthode sin() renvoie sous la forme d’un double le sinus de l’angle (en radians) passé en argument :

public static double cos(double a)

sqrt()

La méthode sqrt() renvoie sous la forme d’un double la racine carrée de son argument :

public static double sqrt(double a) throws ArithmeticException

tan()

La méthode tan() renvoie sous la forme d’un double la tangente de l’angle en radians qui est passé en argument :

public static double tan(double a);

Après avoir pris connaissance des classes dédiées aux types composites et à la manipulation des nombres, vous en savez suffisamment pour extraire par vos propres moyens les informations dont vous avez besoin des autres classes du JDK. Pour vous aider, consultez la documentation en ligne à l’adresse http://docs.oracle.com/javase/8/docs/api/.


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)

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.*;

Les variables

MAX_VALUE représente la valeur maximale qui peut être stockée dans une variable Long : 0x7fffffffffffffff.

MIN_VALUE représente la valeur minimale qui peut être stockée dans une variable Long : 0x8000000000000000.

Le constructeur

Le constructeur Long permet de définir un objet Long à partir d’une variable long ou d’un objet String :

public Long(long value);
public Long(String s) throws NumberFormatException

Exemple :

Long Lx1 = new Long(123456789);
Long Lx1 = new Long("123456789");

Les méthodes

Les méthodes de la classe Long sont pratiquement identiques à celles de la classe Integer. Pour ne pas surcharger cet ouvrage, nous nous contenterons de les citer. Pour de plus amples renseignements, consultez la documentation API (http://docs.oracle.com/javase/8/docs/api/).

Méthode Description
doubleValue() Convertit un objet Long en une valeur double
equals(Object) Teste l’égalité de deux objets Long
floatValue() Convertit un objet Long en une valeur float
getLong(String) Renvoie la valeur d’une propriété Long dont le nom est précisé dans l’argument
getLong(String, long) Renvoie la valeur d’une propriété Long dont le nom est précisé dans l’argument. Si la propriété n’existe pas, le deuxième argument est renvoyé
getLong(String, Long) Renvoie la valeur d’une propriété Long dont le nom est précisé dans l’argument. Si la propriété n’existe pas, le deuxième argument est renvoyé
hashCode() Retourne le hashcode de l’objet sur lequel elle est appliquée
intValue() Convertit un objet Long en une valeur int
longValue() Convertit un objet Long en une valeur long
parseLong(String, int) Convertit un objet String en une valeur Long dans la base de numération spécifiée
parseLong(String) Convertit un objet Long en une valeur Long en base 10
toString(long, int) Convertit une valeur Long en un objet String selon la base de numération spécifiée
toString(long) Convertit une valeur long en un objet String en base 10
toString() Convertit un objet Long en un objet String
valueOf(String, int) Convertit un objet String en un objet Long en utilisant la base de numération spécifiée
valueOf(String) Convertit un objet String en un objet Long

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.*;

Les variables

MAX_VALUE représente la valeur maximale qui puisse être stockée dans une variable float : 3.40282346638528860e+38f.

MIN_VALUE représente la valeur minimale qui puisse être stockée dans une variable float : 1.40129846432481707e-45f.

NEGATIVE_INFINITY représente la valeur -infini.

POSITIVE_INFINITY représente la valeur +infini.

NaN représente une valeur indéterminée.

Le constructeur

Le constructeur Float permet de définir un objet Float à partir d’une variable float ou double :

public Float(float value);
public Float(double value);

Exemple :

Voir méthodes IntValue, longValue, doubleValue, floatValue et hashCode.

Les méthodes

isInfinite()

Cette méthode retourne la valeur true si le float spécifié en argument a une valeur infinie. Elle retourne la valeur false dans le cas contraire :

static public boolean isInfinite(float v);

Exemple :

public class Test {
  public static void main (String args[]) {
    float x = (float) (1/0.0);
    System.out.println(x);
    System.out.println(Float.isInfinite(x));
  }
}

Le premier println affiche la valeur infinite et le second la valeur true. Java considère donc que la valeur stockée dans la variable x est infinie.

Remarque

Vous pouvez également utiliser la méthode isInfinite() pour déterminer si un objet Float a une valeur infinie :

public boolean isInfinite();

toString()

Cette méthode renvoie une chaîne de caractères qui représente le float passé en argument :

public static native String toString(float f);

Exemple :

public class Test {
  public static void main (String args[])
  {
    float x = (float) Math.PI;
    String S;
    S = Float.toString(x);
    System.out.println(S.length());
  }
}

Après conversion du float x en chaîne de caractères :

S = Float.toString(x);

il devient possible d’utiliser les méthodes de la classe String pour travailler sur la valeur convertie du float :

System.out.println(S.length());

Remarque

Vous pouvez également utiliser la méthode toString() pour convertir un objet Float en un objet String :

public String toString();

intValue()

La méthode intValue() retourne la valeur entière de l’objet Double sur lequel elle est appliquée :

public int intValue()

Exemple :

public class Test {
  public static void main (String args[])
  {
    float x = (float) Math.PI;
    Float frr = new Float(x);
    System.out.println(frr.intValue());
  }
}

La première instruction affecte la constante PI à la variable float x :

float x = (float) Math.PI;

La deuxième instruction définit l’objet Float frr à partir de la variable float x :

Float frr = new Float(x);

Enfin, la troisième instruction affiche la valeur entière de l’objet frr :

System.out.println(frr.intValue());

Remarque

Si la valeur à convertir est stockée dans une variable float (et non dans un objet Float), il sera plus simple d’utiliser la syntaxe suivante :

float x = (float) Math.PI;
System.out.println((int) x);

longValue()

La méthode longValue() retourne la valeur entière long de l’objet Double sur lequel elle est appliquée :

public long longValue()

Exemple :

public class Test {
  public static void main (String args[])
  {
    float x = (float) 1486618620.65617;
    Float Fx = new Float(x);
    long Lx = Fx.longValue();
    System.out.println(Lx);
  }
}

La première instruction initialise la variable x :

float x = (float) 1486618620.65617;

La deuxième instruction définit l’objet float Fx à partir de la variable float x :

Float Fx = new Float(x);

La troisième instruction définit la variable long Lx en appliquant la méthode longValue() sur l’objet Float Fx :

long Lx = Fx.longValue();

Remarque

Si la valeur à convertir est stockée dans une variable double (et non dans un objet Double), il sera plus simple d’utiliser la syntaxe suivante :

float x = (float) 1486618620.65617;
long Lx = (long) x;

floatValue()

La méthode floatValue() retourne la valeur réelle float de l’objet Float sur lequel elle est appliquée :

public float floatValue()

Exemple :

public class Test {
  public static void main (String args[])
  {
    float x = (float) 1.234567890123456789e12f;
    Float Fx = new Float(x);
    float fx = Fx.floatValue();
    System.out.println("Le nombre original : " + x);
    System.out.println("Après conversion : " + fx);
  }
}

La première instruction initialise la variable x :

float x = (float) 1.234567890123456789e12f;

La deuxième instruction définit l’objet Float Fx à partir de la variable float x :

Float Fx = new Float(x);

La troisième instruction définit la variable float fx en appliquant la méthode floatValue() sur l’objet Float Fx :

float Fx = Fx.floatValue();

doubleValue()

La méthode doubleValue() retourne la valeur réelle double de l’objet Double sur lequel elle est appliquée :

public double doubleValue();

Exemple :

public class Test {
  public static void main (String args[]) throws java.io.IOException
  {
    double d1;
    String Interm;

    System.out.println("Entrez une valeur réelle float : ");
    Interm = Lit();
    d1=Float.valueOf(Interm).doubleValue();
    System.out.println("Voici sa conversion en double : " + d1);
  }

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

La fonction Lit() acquiert les caractères tapés au clavier et les retourne sous forme d’une chaîne String lorsque la touche Entrée est pressée.

Dans la procédure main(), un message invite l’utilisateur à entrer une valeur réelle float :

System.out.println("Entrez une valeur réelle float : ");

Les caractères tapés sont ensuite mémorisés et stockés dans la variable String Interm :

Interm = Lit();

L’instruction suivante stocke dans la variable r1 la conversion réelle double de la chaîne Interm :

r1=Float.valueOf(Interm).doubleValue();

La méthode valueOf(Interm) convertit la chaîne Interm en un objet Float. Cette méthode fait partie de la classe Float. Elle est dont référencée par Float.valueOf(Interm). On applique ensuite la méthode doubleValue() à l’objet Float qui vient d’être défini, pour le convertir en un réel double…

Remarque

Si la valeur à convertir est stockée dans une variable float (et non dans un objet Float), il sera plus simple d’utiliser la syntaxe suivante :

double d1 = (double) x;

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

Exemple :

public class Test {
  public static void main (String args[])
  {
    float x = 1.2345678f;
    Float Fx = new Float(x);
    System.out.println(Fx.hashCode());
  }
}

La troisième instruction de la procédure main() affiche le hashcode de l’objet Float précédemment défini :

Float Fx = new Float(x);
System.out.println(Fx.hashCode());

equals()

Cette méthode compare l’objet this et l’objet spécifié. Elle renvoie la valeur true si les objets sont identiques et la valeur false dans le cas contraire :

public boolean equals(Object obj)

valueOf()

Cette méthode retourne un objet Float initialisé à la valeur numérique placée dans l’argument String :

public static native Float valueOf(String s) throws NumberFormatException;

Exemple :

Voir la méthode doubleValue().

floatToIntBits()

Cette méthode renvoie la représentation binaire d’une valeur double :

public static native int floatToIntBits(float value);

Exemple :

public class Test {
  public static void main (String args[])
  {
    float x = 123.456f;
    int binaire = Float.floatToIntBits(x);
    System.out.println("Valeur initiale : " + x);
    System.out.println("Conversion binaire : " + binaire);
    System.out.println("Conversion binaire->float : " + Float.intBitsToFloat(binaire));
  }
}

Dans un premier temps, une valeur réelle float est stockée dans la variable x :

float x = 123.456f;

Cette variable est convertie en binaire avec la méthode floatToIntBits() et stockée dans la variable int binaire :

int binaire = Float.floatToIntBits(x);

La valeur initiale et la conversion binaire sont ensuite affichées :

System.out.println("Valeur initiale : " + x);
System.out.println("Conversion binaire : " + binaire);

Enfin, la valeur binaire est reconvertie en un réel float avec la méthode intBitsToFloat() et affichée :

System.out.println("Conversion binaire->float : " + Float.intBitsToFloat(binaire));

intBitsToFloat()

Cette méthode renvoie la représentation float d’une valeur binaire :

public static float intBitsToFloat(int bits);

Exemple :

Voir la méthode floatToIntBits().

parseFloat()

Cette méthode renvoie la représentation String d’un objet Float.