PROGRAMMATION JAVA

Les classes courants:

Les fichiers et expressions régulière

Enseignant: M. N’DOSSANI Année scolaire:2018-2019

 SOMMAIRE

• Base du langage
• Les classes String / Vector/Arraylist /Arrays/
Énumération/ HashTable
• Les classes courants
• Interfaces graphiques
 LES CLASSES COURANTES
• import java.io.BufferedReader;
• java.io.FileReader; java.io.FileNotFoundException;
Les fichiers: lecture java.io.IOException;
class LireLigne {
• On peut utiliser pour cela la classe FileReader. • public static void main(String[] argv) throws
IOException
• FileReader(String nomFichier) ouvre un flux de
lecture à partir du fichier indiqué. Lance une {BufferedReader lecteurAvecBuffer = null; String ligne;
exception si l'opération échoue.
try { lecteurAvecBuffer = new BufferedReader(new
• La classe FileReader possède un certain nombre de FileReader(argv[0]));
méthodes pour lire dans un fichier, méthodes
héritées de la classe Reader. }catch(FileNotFoundException exc)
• Pour lire des lignes de texte dans un fichier texte, on peut {System.out.println("Erreur d'ouverture");}
utiliser la classe BufferedReader. BufferedReader(Reader
in) ouvre un flux de lecture à partir d'un flux d'entrée in. while ((ligne = lecteurAvecBuffer.readLine()) != null)
Ce flux de type Reader peut provenir du clavier, d'un
fichier, du réseau, ... System.out.println(ligne);
Exemple de lecture: on obtient en sortie, à l'écran, le lecteurAvecBuffer.close();
contenu du fichier dont le nom est indiqué sur la ligne de
commande. }
}
 LES CLASSES COURANTES
lecture: utiliser un Scanner
la classe Scanner permet une lecture quelquefois plus aisée des
fichiers. Dans notre exemple, il s'agit d'additionner des entiers
contenus dans un fichier. On donne encore deux possibilités (), selon
qu'on souhaite localiser le fichier par rapport au répertoire
d'exécution ou par rapport au bytecode d'une certaine classe.
• class LireFichierTexte {
• public static void main(String[] arg) throws
java.io.IOException {
• java.util.Scanner lecteur ;
• java.io.File fichier = new java.io.File(arg[0]);
• lecteur = new java.util.Scanner(fichier);
• /* ou bien
• java.io.InputStream entree =
• LireFichierTexteBis.class.getResourceAsStream((arg[0]));
• lecteur = new java.util.Scanner(entree); */
• int somme = 0;
• while (lecteur.hasNextInt()) somme += lecteur.nextInt();
• System.out.println(somme);
• }
• }
 LES CLASSES COURANTES

Les fichiers binaires

• Exemple 3 : pour lire des entiers
dans un fichier ne contenant que
des entiers et d’en faire la somme.
 LES CLASSES COURANTES
Classe de caractère Signification
[abc] Un unique caractère qui peut être a, b ou c.

EXPRESSIONS RÉGULIÈRES [^abc]

Le ^ exprime la négation : cette classe représente un
unique caractère, qui peut prendre toutes les valeurs,
sauf a, b et c.

les expressions régulières sont [a-zA-Z]

Le - signifie que tous les caractères entre ses bornes
sont valides. Cette classe représente un unique

exprimées dans une syntaxe très

caractère alphabétique, minuscule ou majuscule.

précise, très hermétique

Autre exemple d'union : cette classe est constituée de
[a-gmn] tous les caractères compris entre a et g, du caractère
m et du caractère n.

Syntaxe d'une classe d'expression On peut inclure des classes les unes dans les autres.
Cette classe représente un unique caractère, compris

régulière
[a-g[A-G]]
entre a et g, en minuscule ou en majuscule. Elle est
équivalente à [a-gA-G].

Le signe && représente l'intersection. On fait donc là

[a-g&&[c-k]] l'intersection entre la classe [a-g] et la classe [c-k]. Il
s'agit donc de la classe [c-g].

Ici on réalise l'intersection entre la classe qui

représente tous les caractères de a à g, et celle qui
[a-g&&[^cd]] représente tous les caractères, sauf c et d. Il reste
donc a, b, e, f et g, que l'on peut aussi
écrire[abefg] ou [abe-g].

Autre exemple : ici on réalise l'intersection de tous les

caractères compris entre a et z, et de tous les
[a-z&&[^m-p]]
caractères sauf ceux compris entre m et p. Il nous
reste donc [a-lq-z].
 LES CLASSES COURANTES
Classe prédéfinie Classe équivalente Signification
. Un unique caractère quelconque.

EXPRESSIONS RÉGULIÈRES \d
\D
[0-9]
[^0-9]
N'importe quel chiffre.
N'importe quel caractère qui n'est
pas un chiffre.
N'importe quel caractère blanc
\s [ \t\n\x0B\f\r] (espace, tabulation, retour-chariot,
etc...).
Caractère de début ou de terminaison Signification
N'importe quel caractère qui n'est
pas un blanc. Notons que l'on peut
^ Un début de ligne. \S [^\s]
prendre la négation d'une classe
prédéfinie.
$ Une fin de ligne.
N'importe quel caractère utilisable
\b Le début ou la fin d'un mot. dans un mot (w est utilisé pour
word). Cela représente les
caractères alphabétiques
Le début ou la fin d'un élément qui n'est \w [a-zA-Z_0-9] minuscules et majuscules, les
\B
pas un mot. chiffres et le caractère souligné
(underscore). Notons que les
\A Le début d'une entrée. caractères accentués ne s'y trouvent
pas...
La fin du morceau de texte qui a été \W [^\w] Inverse de la classe précédente.
\G N'importe quel caractère minuscule.
trouvé précédemment.
\p{javaLowerCase} Notons que cette fois, les caractères
accentués s'y trouvent !
La fin d'une entrée, sauf s'il s'agit de la N'importe quel caractère majuscule.
\Z
fin du texte. \p{javaUpperCase} Même chose : les majuscules
accentuées s'y trouvent.
La fin d'une entrée, y compris s'il s'agit \p{javaWhitespace} N'importe quel espace.
\z
de la fin du texte. N'importe quel caractère écrit en
\p{javaMirrored}
miroir au sens de Unicode.
 LES CLASSES COURANTES

EXPRESSIONS RÉGULIÈRES
Quantifieurs greed Quantifieurs reluct
• Enfin signalons l'opérateur | : X | Y
Signification
y ant

X? X ??
X apparaît 0 ou
une fois. signifie que le caractère considéré
X apparaît un doit appartenir soit à la classe X ,
soit à la classe Y .
nombre
X* X *?
quelconque de
fois.
X apparaît 1 fois et
X+ X +?
plus.
X apparaît
X {n} X {n}?
exactement n fois.
X apparaît au
X {n,} X {n,}?
moins n fois.
X apparaît au
X {n, m} X {n, m}? moins n fois et au
plus m fois
enum Civilite {MADAME, MADEMOISELLE, MONSIEUR} ; Civilite civilite = Civilite.MADAME ;

BASE DU LANGAGE
exemple
Déclaration d'une public enum Jour {
énumération LUNDI, MARDI, MERCREDI, JEUDI, VENDREDI,
SAMEDI, DIMANCHE;}
public enum Civilite { // dans le fichier Civilite.java
class EssaiJour {public static void main(String[] arg) {
MADAME, MADEMOISELLE, MONSIEUR Jour jour = Jour.valueOf(arg[0]);
} if (jour == Jour.SAMEDI)
Exemple: System.out.print("fin de semaine : ");
enum Civilite {MADAME, MADEMOISELLE, MONSIEUR} ; switch(jour) {case SAMEDI :case
DIMANCHE :
Civilite civilite = Civilite.MADAME ; System.out.println("se reposer");
break;
Un type énuméré permet de définir
default :
un ensemble d'identificateurs pour System.out.println("travailler");
des constantes break;}}}
 BASE DU LANGAGE
La classe Array fournit des méthodes
simples pour afficher un tableau sous
Classe Arrays forme de chaîne de caractères
• Cette classe expose des méthodes utilitaires qui traitent
des tableaux.
string[] monTableau = new string[]
La première méthode exposé permet de convertir un
{Un, Deux, Trois};
tableau en List : asList(Object[] tab). Attention toutefois, la
liste retournée ne supporte pas l'ajout d'objet ! Arrays.toString(monTableau);
Utilisation de Arrays.asList(...)
// jusqu'ici tout va bien...
List<String> list = Arrays.asList("Un", "Deux", "Trois") ;
// génération d'une UnsupportedOperationException
list.add("Quatre") ;

initialiser un ArrayList
la classe ArrayList est utilisée pour
stocker et accéder à des données. Il
faut dans un premier temps initialiser
la liste puis y ajouter les éléments un
par un avec la méthode add().
ArrayList couleurs = new ArrayList();
couleurs.add(Rouge);
couleurs.add(Bleu);
couleurs.add(Vert);
BASE DU LANGAGE
Structure de choix simple
• syntaxe :
if(condition){actions_condition_vraie;}
Else {actions_condition_fausse;}
On peut imbriquer les structures de choix :
if(condition1) if (condition2){......}
else //condition2{......}
else //condition1
{.......}