Cours JAVA

Support pedagogique d’introduction au langage Java


Télécharger Support pedagogique d’introduction au langage Java

★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Télécharger aussi :


Support pédagogique d’introduction au langage Java

...

11.2 Graphics2D

La classe Graphics2D est une extension de la classe java.awt.Graphics. Elle réalise, donc toutes les méthodes de la classe Graphics, parmi lesquelles :

Ainsi qu’un ensemble de fonctions complémentaires :

¥ Motifs linéaires ;

I.U.T. de Paris 13 A.Osmani

Département Informatique Formation initiale

  • Transformation d’objets ;
  • Remplissage de motifs et de couleurs ;
  • Zone d’affichage variable
  • Mélange de couleurs lorsque plusieurs objets se coupent.

11.3 Accessibilité

Ces API permettent d’intégrer des périphériques d’entrées et sorties spéciaux. Le package correspondant est le package : javax.accessibility

11.4 Glisser et déplacer

Les fonctionnalités Drag and Drop permettent de transférer des données entre plusieurs applications ou à l’intérieur d ‘une même application. Le package java.awt.dnd assure ces possibilités.

11.5 Les swing

La procédure de construction d’une interface en utilisant les Swing est la même que celle utilisant les AWT. Elle consiste à créer des cadre, des composants dans le cadre, de faire une mise en page des composants et de réaliser les méthodes pour la gestion des réponses aux actions des utilisateurs.

La maîtrise de ce package ne peut se faire sans une utilisation effective des classes de ce package dans une application réelle. Cette section présente quelques éléments de base des swing.

11.5.1 Composants

Un composant est l’entité fondamentale d’une interface utilisateur. Tout ce que l’on voit sur l’écran d’une application java est un composant. Ceci comprend des fénêtres, des boutons, des cases à cocher, etc. Pour être utilisé, un composant doit généralement être placé dans un conteneur.

JComponent est la racine de l’arborescence de composants Swing. Elle descend de la classe Container du paquetage AWT. .

Jcomponent héritant de Container, possède à la fois des capacités d’un composant et d’un container.

Les fonctionnalités d’un objet JComponent peuvent être divisées en deux catégories :

apparence (taille, emplacement, etc.) et comportement (réaction de l’objet par rapport aux événements contrôlés par l’utilisateur ).

Parmi les méthodes de Jcomponent, on peut citer :

  • Container getParent() : renvoie le conteneur hébergeant ce composant ;
  • String getName(), void setName(String nom) : obtient ou affecte le nom String à ce composant.
  • Void setVisible (boolean v) : rend le composant visible ou invisible dans son conteneur.
  • Color getForeground(), void setForeground(Color a), Color getBackground()
  • Dimension getSize(), void setSize(int largeur, int longueur)
  • Cursor GetCursor(), void SetCursor(Cursor a) : obtient ou définit le type de pointeur de la souris au dessus de ce composant Les composants sont presque les mêmes que ceux des AWT.
  • JButton
  • JLabel
  • JTextArea
  • JTextField
  • JCheckBox
  • JScrollBar
  • JList
  • JPasswordField

 11.5.2 Conteneur

Un conteneur sont des objets dans lesquels sont incorporés des composant. Etant donnée que la classe JComponent hérite de la classe Container, des objets JComponent peuvent donc être des containers.

Exemples de conteneurs :

  • JFrame , Jpanel : ils représentent un cadre spécifique à l’environnement ;
  • JSrollPane. Il s’agit d’une barre de défilement. Vous pouvez, par exemple, ajouter un JscrollPane puis un Jbouton à un Jframe ;
  • JDialog. C’est une boite de dialogue qui apparaît au milieu de l’écran ;

Pour être traités (affichage et positionnement), les composants doivent être intégrés à un conteneur.

  • La méthode add(), de la classe Container, permet d’ajouter un composant conteneur
  • La méthode remove( )permet d’enlever un composant d’un conteneur.

 11.5.3 Gestionnaire de placement

Un gestionnaire de placement est un objet qui contrôle le placement et la taille des composants situés à l’intérieur de la zone d’affichage d’un conteneur.

Java fournit de nombreux gestionnaires de placement et il est tout à fait possible de créer ses propres gestionnaires de placement par la méthode setLayout().

  • FlowLayout (Gestionnaire de placement, par défaut, d’un JPanel ) : place les objets suivant l’alignement spécifié par les constantes LEFT, CENTER ou RIGHT.
  • BorderLayout (Gestionnaire de placement, par défaut, d’un JFrame) : contrairement à FlowLayout qui contrôle complétement la position de chaque composant, BorderLayout place les objets à des emplacements désignés de la fenêtre : au centre, au nord, au sud, à l’est ou à l’ouest. L’instruction, ci-dessus, permet de placer un composant en haut d’un containeur :

myContainer.add(myComponent, BorderLayout.NORTH);

11.6 Gestion d’événements

Les gestionnaires d’événements permettent d’intercepter les actions des utilisateurs et d’assigner au programme un comportement adapté en réponse. Il existe de nombreuses manières de gérer les événements. Ce chapitre propose une manière classique, c’est celle qui est utilisée par défaut par Jbuilder. Elle se met en œuvre en trois temps : création d’un écouteur d’actions qui attend et capte les actions de l’utilisateur, d’une méthode qui met en œuvre la réponse adaptée, da la classe qui définie cette méthode.

Les objets de Swing communiquent en envoyant des événements. Les événements sont envoyés par un objet source à un ou plusieurs objets listeners. Un listener implémente les méthodes qu’il faut pour gérer les événements qu’il reçoit. Il s’enregiste ensuite auprès d’une source de ce type de message. Parfois, il est nécessaire de définir un adapter entre la source de l’événement et le listener, mais l’inscription d’un listener auprès d’une source se fait toujours avant l’envoi des événements.

Les objets événements héritent de la classe java.util.EventObject. Ils contiennent les informations sur ce qui s’est produit dans la source. La classe EventObject sert à identifier

les objet événements, sa seule information est une référence à la source des événements.

Un ActionEvent correspond à une action déterminante décidée sur le composant par l’utilisateur. Il transporte le nom de l’action à effectuer. Par exemple, les MouseEvent sont générés lorsque la souris se déplace dans la zone du composant. Ces événements véhiculent les informations concernant la souris : les coordonnées, les boutons appuis, etc. Les ActionsEvent fonctionne à un niveau plus élevé que les MousseEvent : il indique qu’un composant a terminé sa tâche.

11.6.1 Récepteurs d’événements

Un événement est transmis sous forme d’argument de la méthode de gestion d’événements de l’objet récepteur. Par exemple, les ActionEvent sont toujours transmis à la méthode

actionPerformed du récepteur. public void actionPerformed(ActionEvent e)

A chaque type d’événements correspond une interface listener qui indique comment il sera traité.

Les objets qui recoivent des ActionEvent implémentent l’interface ActionListener qui contient la méthode actionPerformed.

public interface ActionListener extends java.util.EventListener { public void actionPerformed ( ActionEvent e) ; }

EventListener est une interface vide. C’est l’interface de base de toutes les interfaces listener

11.6.2 Sources d’événements

Pour recevoir des événements, les listener s’enregistrent auprès d’une source d’événements en appelant une méthode de la source en lui passant sa propre référence. Exemple : la classe Jbutton est une source d’événements. Un objet de la classe MaClasse va s’inscrire comme suit :

class MaClasse implements ActionListener

{ void abonnement (JButton b)

{ b.addActionListener(this) ; // L’objet qui execute cette méthode va recevoir les

ActionEvent

// en provenance du bouton b. il envoie sa propre référence

}

public void actionPerformed (ActionEvent e) { }

}

Pour gérer les listeners, une source d’ActionEvent, comme JButton de l’exemple précédent, implémente toujours deux méthodes

public addActionListener (ActionListener e) { } et

public void removeActionListener(ActionListener e){ }

dans le cas des awt ou des swing les événements sont associés à une unique source. Il peut être distribué à un nombre quelconque de Listeners. Lorsqu’un événement est déclenché, il est distribué individuellement à chaque listener, l’ordre ainsi que l’unicité de la distribution ne sot pas garantis.

11.6.3 Les Adapteurs

En général, il n’est pas souhaitable et parfois impossible que les composants de votre application reçoivent directement des événements. Car l’implémentation d’interface listeners vous oblige à ajouter le traitement des événements. Une solution consiste à placer une classe adapteur entre la source et le récepteur des événements.

Un objet adapteur fait correspondre un événement entrant en une méthode de sortie

Exemple :

class Adapteur implements ActionListener

{ MaClasse a ;

Adapteur (MaClasse x) { a = x ; }

public void actionPerformed (ActionEvent e) { a.laméthode(); }

public static void main (String [] a)

{ MaClasse classe = new MaClasse();

//É

Jbutton leBouton = É

// établissement de la liaison

leBouton.AddActionListener(new Adapteur(classe)) ;

...

La classe InputStream

Object   InputStream (abstract)

Toutes les méthodes de classe lèvent les exceptions IOException. Les méthodes read se bloquent tant que l’entrée n’est pas disponible.

Les méthodes de la classe InputStream sont :

  • public int available() throws IOException. Elle renvoie le nombre d’octets actuellement disponible pour la lecture.

Exemple : InputStream x = ... ;

...

int compteur =x.available() ;

  • public void close() throws IOException. Elle ferme le flux d’entrée

Exemple : InputStream x = ... ; ...

int entree =x.read() ;



...

x.close() ;

  • public synchronized void mark (int TailleTamponPourLaLectureAnticipée). Elle marque la position en cours et fixe la taille du tampon pour la lecture anticipée.

Exemple : InputStream x = ... ;

if (x.markSupported())

{ x.mark (4);

int tab=new tab[4] ;

for(int i=0 ;i<tab.length ;i++) tab[i]=x.read() ;

x.reset() ;

if (tab[0] =="blabla") System.out.print("type 1") ;

...

else System.out.println("Inconnu") ;

}

  • public boolean markSupported(). Elle vérifie si mark() et reset() fonctionnent pour une lecture anticipée.
  • read(). Elle lit des octets des flux d’entrée.
  • public abstract int read() throws IOException : lecture d’un seul octet ;
  • public int read(byte buffer[]) throws IOException : lecture de buffer.length maximum;
  • public int read (byte buffer[], int débutTamponDeLecture, int TailleMaxiALire) throws IOException : lecture de TailleMaxiALire octets maximum vers un tableau commençant à partir de débutTamponDeLecture
  • public synchronized void reset() throws IOException. Elle replace la position de lecture sur l’emplacement marqué, si la limite de lecture n’a pas été dépassée.
  • public long skip (long NombreOctetsDontDoitAvancerPositionCourante). Elle déplace la position de lecture vers l’avant.

Exemple : InputStream x = ... ;

x.skip(10) ;

int x1 = x.read() ;

Nous avons l’habitude d’utiliser la classe System. Nous avons utilisé, essentiellement, la méthode print() associée à l’objet System.out. Il est également possible d’utiliser la méthode read() associée à l’objet System.in pour la lecture d’un octet. Ceci se fait de la façon suivante :

try

{ byte b =(byte)System.in.read();

int nombreOctetsDisponibles = System.in.available() ;

// available permet de vérifier le nombre d’octets disponibles

//ensuite un tableau permettant de contenir tous les octets est crée

if (nombreOctetsDisponibles >0)

{ byte[] entrée = new byte[nombreOctetsDisponibles] ;

System.in.read(entrée) ;

}

} catch (IOException e)

{ System.out.println(“L’exception est “ + e);

}

12.3 La classe OutputStream

La classe OutputStream est une classe abstraite qui hérite de la classe Object. C’est la superclasse pour toutes les opérations de sortie au niveau octet.

public abstract class OutputStream Les méthodes de cette classe sont :

  • public void close() throws IOException : permet de fermer un flux de sortie
  • public void flush() throws IOException : garantit que les octets dans le tampon sont bien écrits
  • public void write(byte buffer[]) throws IOException : permettent d’écrire des octets sur le flux de sortie.
  • public void write(byte buffer[], int offset, int length) throws IOException. Buffer est le tampon à partir du que écrire les octets, length est le nombre d’octets à écrire
  • public void write(int leByte) throws IOException . offset est la position de départ du tampon à partir de laquelle écrire. Exemple :

OutputStream os = É ; os.write(123) ; os.flush; os.close();

12.4 Les flux de caractères(classes Reader et Writer)

Certaines classes dérivées des classes InputStream et OutputStream permettent la gestion de chaînes, mais elles considèrent des caractères unicode (2octets) équivalent à un octet. Ceci ne fonctionne qu’avec les caractères ISO 8859-1. Les classes Reader et Writer sont introduites dans la version 1.1 pour palier ce manque.

Les deux classes InputStreamReader et OutputStreamWriter permettent de convertir des octets en caractères et vice versa. Un schéma d’encodage peut être indiqué dans les constructeurs de ces classes.

Exemple : Les octets entrants de System.in sont convertit en caractères en les enveloppant dans un InputStreamReader. Le flux InputStreamReader est enveloppé dans BufferedReader qui offre la méthode readLine(). La méthode readLine() permet de convertir une ligne de texte en String. Puis la chaîne est convertit en un entier.

try

{ InputStreamReader convert = new InputStreamReader(System.in);

BufferedReader in = new BufferedReader(convert);

String laligne = in.readLine();

int entire = NumberFormat.getInstance().parse(laligne).intValue();

} catch (IOException e) {}

catch (ParseException ee){}

12.4.1 Classe Reader

La classe Reader est la superclasse de toutes les opérations d’entrée au niveau caractère. La classe Reader contient une variable d’instance : protected Object lock. Elle contient l’objet à verrouiller pour les sections de code critique. L’objet lock permet de synchroniser les accès à des blocs de code critique (nous n’allons pas aborder ce point dans ce cours).

L’ensemble des méthodes de cette classe sont :

  • protected Reader() et protected Reader(Object lock) automatiquement appelés par des sous-classes pour créer un Reader.
  • public abstract void close() throws IOExection. Elle ferme les flux d’entrée.
  • public void mark(int TailleTamponPourLaLectureAnticipée). Elle marque la position en cours et fixe la taille du tampon pour la lecture anticipée.
  • public boolean markSupported(). Elle vérifie si mark() et reset() fonctionnent pour une lecture anticipée.
  • read(). Elle lit des octets des flux d’entrée.
  • public int read() throws IOException
  • public int read(char buffer[]) throws IOException
  • public int read (char TamponOuLireLesCaractères[], int débutTamponDeLecture, int TailleMaxiALire) throws IOException
  • public boolean ready() throws IOException. Elle vérifie la disponibilité des données pour empêcher un blocage de la lecture. Elle renvoie true si la prochaine opération de read() est assurée de ne pas avoir à attendre l’entrée des données, false si la garantie ne peut pas être donnée.

12.4.2 Classe Writer

public abstract class Writer

Writer est la superclasse de toutes les classes assurant les opérations au niveau caractères. Cette classe contient une variable d’instance (protected Object lock) pour le verrouillage des sections critiques. Parmi les méthodes de cette classe on y trouve :

  • protected Writer()
  • protected Writer(Object o)
  • public abstract void close() throws IOException. Elle ferme les flux de sortie
  • public abstract void flush() throws IOException. Garantit que tous les caractères placés dans un tampon sont écrits.
  • public void write(char [] buffer) throws IOException. Écrit les caractères dans un flux de sortie. buffer : tampon à partir duquel écrire les caractères
  • public abstract void write (char[]buffer, int offset , int length) throws IOException. Position de depart du tampon où doit commencer la lecture. length est le nombre de caractères maximum à lire
  • public void write(int leChar) throws IOException.
  • public void write(String buffer) throws IOException
  • public void write(String buffer, int offset,int length) throws IOException

...

Les classes DataInputStream et DataOutputStream

Elles permettent le lire et d’écrire des types de données de base comme les nombres et les objets String.

La classe DataInputStream :

public class DataInputStream extends FilterInputStream implements DataInput

Les classes DataInputStream et DataOutputStream permettent de lire et d’écrire les chaînes de caractères et les types de base codés sur plusieurs octets. La classe DataOutputStream implémente à son tour l’interface DataOutput. Les interfaces DataOutput et DataInput définissent les méthodes qui lisent les chaînes de caractères, des types numériques de base ainsi que des booléens.

L’exemple suivant permet la lecture d’un double à partir du clavier.

DataInputStream dis = new DataInputStream(System.in) ; double x =dis.readDouble();

Que fait le programme suivant

import java.io.*;

class TestIO7

{ public static void main (String []ar)

{ DataInputStream clavier = new DataInputStream (System.in);

try

{ while (true)

{ byte b2 = (byte)clavier.readByte();

System.out.print ((char)b2);

}

} catch (IOException e)

{ System.out.println ("Problème");

} }}

Exemple : Nous avons vu que la class DataInputStream ne permet de lire que des types numériques.

DataInputStream x = É ;

float y=x.readFloat() ;

d’un autre coté, la classe FileInputStream permet d’accéder à des octets dans les fichiers.

En java, c’est le programmeur qui doit combiner ces deux flux pour pouvoir lire des types numériques, par exemple, dans un fichier. Ceci est obtenu, en passant aux constructeurs des nouveaux objets des flux existant. Ce mécanisme est appelé flux filtrés.

Pour notre exemple utilisant les flux FileInputStream et DataInputStream, la construction du flux filtré se fait comme suit :

FileInputStream a = new FileInputStream("f1.txt”);

DataInputStream x = new DataInputStream(a);

float y = x.readFloat();

La combinaison des flux est utile pour créer les flux dont on a besoin. Un autre exemple intéressant est celui de la bufférisation des données. Par défaut, les flux ne sont pas bufférisés. Ce qui nécessite un appel système pour tout transfert d’un octet dans le cas du flux FileInputStream, par exemple. Pour réduire le nombre d’appels système on peut

buffériser les octets entrant en combinant les flux BufferedInputStream et FileInputStream.

Si l’objectif est de lire des float à partir d’un fichier, en utilisant la bufférisation, voici l’empilement des flux qui permet d’atteindre cet objectif.

DataInputStream x =new DataInputStream ( new BufferedInputStream

( new FileInputStream (“f1.txt”) ) );

12.6 Les classes FileInputStream et FileOutputStream

La classe java.io.FileInputStream permet de définir un flux d’entrée à partir d’un fichier public class FileInputStream extends InputStream { ... }

Les méthodes de cette classe sont :

  • public FileInputStream(File f) throws FileNotFoundException
  • public FileInputStream(FileDescriptor fd)
  • public FileInputStream(String f) throws FileNotFoundException permettent de construire un FileInputStream à partir d’une source appropriée.
  • protected finalize() throws IOException. Elle garantit la fermeture du fichier lorsque le garbage collector a récupéré l’espace alloué au flux
  • public final FileDescriptor getFD() throws IOException. Elle donne le descripteur de fichier du flux de fichier Exemples :

try



{ FileInputStream fis = new FileInputStream("leNomDeFichier”);

readStream (fis);

} catch ( FileNotFoundException e)

{ System.out.print(“Fichier introuvable”);

}

import java.io.*;

class TestIO9

{ public static void main (String []ar)

{ DataInputStream a= new DataInputStream(System.in);

String t="";

try

{ while (true)

{ byte b = (byte)a.readByte();

if ((char)b=='0') break;

t=t + (new Character((char)b)).toString();

};

FileInputStream fis = new FileInputStream (t);

} catch (FileNotFoundException e) {System.out.println ("Fichier introuvable");}

catch (IOException e){ System.out.println("IO");}

}

}

...

L’interface serializable

Les objet de type DataOutputStream permettent d’écrire des objets quelconque sous forme de type simple. La sérialisation est un mécanisme plus puissant et plus élégant permettant d’enregistrer des graphes d’objets sur disque. Elle permet de concerver l’état des objets entre deux exécutions d’un programme ou d’échanger des objets entre applications.

La sérialisation est un moyen automatique permettant de charger et de sauver l’état d’un objet.

Un objet quelconque implémentant l’interface serializable peut être chargé et sauvé à partir d’un flux. Le mécanisme de sérialisation par défaut sauvegarde les valeurs des variables d’instances et non les variables statiques et les transients2.

Lorsqu’un objet est sérialisé toutes les références d’objets qu’il contient le sont également.

Ceci lui donne la possibilité de sauver des graphes entiers. Il faut donc s’assurer que les objets référencés par des objets sérialisés doivent être aussi sérialisés.

Exemple :

Public class Personne implements Serializable

{ String nom;

Dossier dossier;

transient String temp ;

//É

public static void main(String [] a) throws IOException

{ Dossier d = É ;

Personne p = new Personne("p1", d);

p.temp= "nouvelle Valeur" ;

ObjectOutputStream o =new ObjectOutputStream(new FileOutputStream("fichier1Ó));

o.writeObject(p);

o.close();

try

{ ObjectInputStream e= new ObjectInputStream(new FileInputStream(“fichier1Ó));

Personne p1 =(Personne)e.readObject();

p1.affiche() ; // la valeur de p1.temp est perdue

e.close();

} catch (ClassNotFoundException e) {}

}

}

class Dossier implements Serializable

{ int numero

// É

}

12.10 Les flux de fichiers ZIP

Les fichiers ZIP sont des archives contenant un ou plusieurs fichiers dans un format compressé. Java 2 accepte les format GZIP et ZIP.

L’entête d’un fichier Zip contient les informations concernant le nom du fichier, la méthode de compression utilisée, etc.

Java permet de lire des fichiers ZIP à l’aide de la classe ZipInputStream en empilant le constructeur ZipInputStream sur un FileInputStream. De cette façon on accède individuellement à chaque entrée de l’archive.

La méthode getNextEntry permet de renvoyer une entrée de type ZipEntry. La méthode ZipInputStream permet de renvoyer –1 à la fin de l’entrée courante. Ce qui impose de faire closeEntry sur l’entrée courante pour pouvoir accéder à l’entrée suivante.

Exemple :

ZipInputStream zin = new ZipInputStream (new FileInputStream(“nom”));

ZipEntry e;

While (e =zin.getNextEntry())!=null)

{ // traitement de e

zin.closeEntry() ;

}

12.11 Complément flux d’entrées/sortie

12.11.1 Saisir des données envoyées par le clavier

Les deux exemples suivants montrent comment lire des données envoyées tout simplement par le clavier.

Les deux programmes d'illustration ont pour objectif de lire des entiers envoyés par l'intermédiaire du clavier, et d'en faire la somme. Leurs cahiers des charges diffèrent uniquement sur la façon d'indiquer la fin de la saisie.

Première méthode

La classe InputStreamReader admet un constructeur InputStreamReader(InputStream), c'est-à-dire un constructeur qui admet en paramètre un flot d'entrée. System.in est une instance de la classe InputStream. Avec une instance de InputStreamReader, on ne peut grosso modo que lire des caractères un à un.

La classe BufferedReader a un constructeur qui prend en argument une instance de Reader dont hérite la classe InputStreamReader. Cette classe permet en particulier de lire une ligne d'un texte, mais en revanche, on ne peut pas lui demander de lire un entier, un double etc...

On lit ici ce qui est envoyé par le clavier ligne par ligne et on découpe le contenu de chaque ligne avec un StringTokenizer pour récupérer les entiers attendus.

Vous devez taper return deux fois de suite pour interrompre la saisie.

Voici le programme que nous proposons.

import java.io.*;

import java.util.*;

class SaisieClavier

{ public static void main (String[] argv) throws IOException, NumberFormatException

{ int somme = 0;

String ligne;

StringTokenizer st;

BufferedReader entree = new BufferedReader(new InputStreamReader(System.in));

ligne = entree.readLine();

while(ligne.length() > 0)

{ st = new StringTokenizer(ligne);

while(st.hasMoreTokens())

somme += Integer.parseInt(st.nextToken()); ligne = entree.readLine();

}

System.out.println("La somme vaut : "+somme);

}}

Deuxième méthode

On utilise ici une instance de StreamTokenizer qui est un analyseur syntaxique plutôt rudimentaire.

Un constructeur de la classe StreamTokenizer prend en paramètre une instance de Reader. La méthode nextToken() de la classe StreamTokenizer retourne le type de l'unité lexicale suivante, type qui est caractérisé par une constante entière. Cela peut être :

TT_NUMBER si l'unité lexicale représente un nombre. Ce nombre se trouve alors dans le champ nval de l'instance de StreamTokenizer. Ce champ est de type double.

TT_WORD si l'unité lexicale représente une chaîne de caractères. Cette chaîne se trouve alors dans le champ sval de l'instance du StreamTokenizer.

TT_EOL si si l'unité lexicale représente une fin de ligne. La fin de ligne n'est reconnue comme unité lexicale que si on a utilisé l'instruction nomDuStreamTokenizer.eolIsSignificant(true);

TT_EOF s'il s'agit du signe de fin de fichier.

import java.io.*;

class EssaiStream

{ public static void main (String[] argv) throws IOException

{ int type, somme = 0;

StreamTokenizer entree= new StreamTokenizer(new InputStreamReader(System.in));

String fin=new String("fin");

System.out.println("Donnez vos entiers, terminez avc fin");

while(true)

{ type=entree.nextToken();

if (type==StreamTokenizer.TT_NUMBER) somme += (int)entree.nval;

else if ((type == StreamTokenizer.TT_WORD)&& (fin.equals(entree.sval)))

break;

}

System.out.println("La somme vaut : " + somme);

}}

Voici une exécution :

Donnez vos entiers, terminez avec fin

1 -2 bonjour 4

3 fin 2

La somme vaut : 6

12.11.2 Lire ou écrire des caractères dans un fichier

Le programme ci-dessous écrit une chaîne de caractères dans un fichier nommé copie_essai.txt puis copie le fichier essai.txt caractère par caractère dans le fichier copie_essai.txt.

import java.io.*;

class LireEcrireTexte

{ public static void main(String[] argv) throws IOException

{ FileReader lecteur;

FileWriter ecrivain;

int c;

lecteur = new FileReader("essai.txt");

ecrivain = new FileWriter("copie_essai.txt");

ecrivain.write("copie de essai.txt\n");

while((c = lecteur.read()) != -1) ecrivain.write(c);

lecteur.close(); ecrivain.close();

}

}



221