1

INTRODUCTION À « JAVA »
 Qu’est ce que « Java » ?
2

 Un langage de programmation interprété et

compilé.
 Langage portable : pseudo-code

 Quels types d’application pour « java » ?

 Comment cela fonctionne t’il ?
3

L’interprète est une machine virtuelle plus connue sous

le nom de « jvm ».
 Le « Java Development Kit »
4

 Java est un langage de programmation.

 Le « Java Development Kit » est une boite à outils

:
 il fournit un compilateur java
 il fournit une machine virtuelle « jvm »
 il fournit un ensemble de bibliothèques d’outils pour
faciliter la programmation.
 Quelques atouts de java
5

 Les principaux atouts de java :

 génère des applications portables,

 un langage simple et puissant,

 un langage qui introduit directement la notion de

thread,

 une API très riche,

 une gestion automatique de la mémoire.

 6

LES BASES DU LANGAGE

JAVA
 Notion de « class »
7

 « java » est un langage objet et permet de définir des classes :

class nom_de_la_class
{
corps de la classe
}

 Le langage « java » oblige à ce que le fichier contenant la description d'une classe

porte le nom de celle-ci.

Nous ne pourrons décrire qu'une classe par fichier.

 Héritage de classe
8

 Une classe peut hériter d’une autre classe.

class nom_de_la_class extends nom_de_la_classe_mère

{
corps de la classe
}

L’héritage multiple n’existe pas en java.

 Attributs de classe
9

 Un attribut est une donnée d'une classe dont la déclaration respecte la

syntaxe :

type_de_l'attribut nom_de_l'attribut [ = valeur ] ;

 Par exemple :

int a;
float pi = 3.14;
float rayon = 5;
float surface = pi * pi * rayon;
 Les types de base
10

 Comme tous langages de programmation, java propose un ensemble de

types de base :
 byte,
 boolean
 short,
 int,
 long,
 float,
 double,
 char.

 Il n’existe pas en java de types non signés.

 Méthodes
11

 Une fonction d’une classe est appelée « méthode ».

 En java une méthode peut retourner une valeur et avoir une liste de paramètres :

type_de_retour nom_de_méthode ( liste_des_paramètres )

{
corps de la méthode
}

 Exemple :

int addition( int a, int b )

{
return a + b;
}
Le mot clef « return » permet de renvoyer une valeur
 Les paramètres des méthodes
12

 Une méthode peut avoir un nombre quelconque de paramètres.

 Tous les paramètres sont passés par valeur.

 Un paramètre ne peut pas être déclaré avec un modificateur (

abstract, final, static )

 Format d'un paramètre :

type_du_paramètre nom_du_paramètre
 Les constructeurs de classe
13

 Un constructeur est une méthode automatiquement appelée lors de la

création d’une instance d’une classe.

 Si aucun constructeur n’est défini par le programmeur, java considère que

la classe est munie d’un constructeur par défaut.

 Règles des constructeurs en java :

 Les constructeurs en java portent le nom de la classe.
 Les constructeurs n’ont pas de type de retour.
 Une même classe peut avoir plusieurs constructeurs qui doivent se distinguer par
leurs paramètres.
 Si une classe hérite d’une autre classe, son constructeur doit appeler
impérativement celui de la classe mère en utilisant le mot clef « super ».
 Exemple de constructeur
14

public class base

{
int add( int a, int b ) Pas de constructeur défini
{
return a + b;
}
}

public class herite extends base

{ Un constructeur sans paramètre est
herite() équivalent à un constructeur par défaut.
{} De plus s'il n'effectue aucun traitement
} il est inutile.
 Autre exemple
15
public class base
{
base()
{} Constructeur inutile.
int add( int a, int b )
{
return a + b;
}
}

public class herite extends base

Appel à super inutile car
{ la classe mère n'a qu'un
herite( int a ) constructeur par défaut.
{
super( );
System.out.println( "Création de herite : " + a )
}
}
 Création d ’une instance de classe
16

 Pour créer une instance d’une classe on utilise l’opérateur « new »

maClasse monInstance = new maClasse();

 Pour supprimer une instance d'une classe on doit affecter la référence de

celle-ci à « null »

monInstance = null;

 L'instance n'est pas détruite immédiatement mais uniquement lors de la

mise en route du garbage collector. On peut activer le garbage collector par
l'instruction :

System.gc();
 Espace de désignation
17

 Plusieurs classes peuvent être rassemblés au sein d'un « package ».

 Pour indiquer qu'une classe est membre d'un package on utilise le mot clef
« package » :

package Premier;

class toto { … }

 Un package peut être vue comme un répertoire dans lequel est rangé la
classe java.
 Un package introduit un espace de désignation ( plusieurs classes peuvent
porter le même nom si elles sont placées dans des packages différents ).
 Utilisation des « packages »
18

 Pour accéder à un élément défini dans un package on doit utiliser son nom
complet sauf si l'élément qui l'utilise est dans le même package :

nom_de_package . nom_de_l'élément

 Exemple :

package Exemple; package Exemple;

class toto class titi extends toto
{…} {…}

class tutu extends Exemple.titi

{…}
 Arborescence de « package »
19

 On peut définir une arborescence de package en incluant un package dans

un autre package.

 Pour ajouter une classe dans un tel package, on utilise également le mot
clef « package » suivit du chemin désignant le package.

 Exemple :

package Exemple.SousPackage;

class toto { … }
 Importation de « package »
20

 Le langage java fournit une facilité d'écriture par l'emploi de la

notion d'importation de package.

 En utilisant le mot clef « import », on importe les définitions un ou

plusieurs éléments d'un package.

 Exemple :

package Exemple; package Exemple;

class toto class titi extends toto
{…} {…}

import Exemple.*;
class tutu extends titi
{…}
 Le modificateur « abstract »
21

 Une classe, une interface ou une méthode peuvent être spécifiés comme
étant abstraite en utilisant le mot clef « abstract ».
 On ne pourra pas créer d'instance d'une classe abstraite, ou d'une classe
possédant une méthode abstraite.
 De plus un classe qui possède une méthode abstraite doit obligatoirement est
marqué abstraite.

 Implicitement, toutes les interfaces sont abstraites, l'utilisation du mot clef «

abstract » est obsolète.

 Le modificateur « abstract » intervient en complément des autres

modificateurs comme « public » ou « private ».
 Le modificateur « final »
22

 Une classe, un attribut, une méthode et une interface peuvent être

spécifiés comme « final ».

 On emploi le mot clef « final » pour signaler qu'un élément est final.

 Dans ce cas on ne pourra pas soit surcharger ( dans le cas d'une

classe, d'une méthode ou d'une interface ), soit modifier ( dans le
cas d'un attribut ).

 Exemple :

public class Exemple

{
public final float pi = 3.14;
}
 Le modificateur « static »
23
 Le modificateur « static » peut s'appliquer à une méthode ou un
attribut d’une classe. Dans ce cas, l'élément statique est partagé
par toutes les instances de la classe. On dit que l’élément est porté
par la classe. Il est aussi possible d’y accéder sans disposer d’une
instance, mais directement par la classe.

 Une méthode ou un attribut statique ne doit employer pour ses

traitements que des méthodes ou attributs statiques.

 Exemple :
public class Exemple
{
public final float pi = 3.14;

public static void float perimetre( float rayon )

{ return rayon * 2 * pi; }
}

Erreur car pi n'est pas statique.

 L ’Attribut caché « this »
24

 Chaque instance de classe comporte un attribut appelé « this » qui

désigne l'instance courante de la classe.

 Cette attribut peut être utile pour retourner une référence vers l'instance ou
pour lever certaines ambiguïtés sur les identifiants.

 Exemples :
public float longueur;
public void fixeLongueur( float longueur )
{
this.longueur = longueur;
}
 Les tests de conditions
25

 Les tests de conditions en java sont

équivalents à ceux du C ou du C++ :

if ( condition )
// Bloc d'instruction si la condition est vraie
else
// Bloc d'instruction si la condition est fausse
 Les choix multiples
26

 On peut également utiliser une structure à

choix multiples :

switch ( type )
{
case valeur :
// Bloc d'instructions
default :
// Bloc d'instructions par défaut
}
 Les boucles
27

 Plusieurs types de boucles existent en java au même titre qu'en C ou C++ :

for ( compteur; max; increment )

// Bloc d'instructions

while ( condition )
// Bloc d'instructions exécuté tant que la condition est vraie

do
{
// bloc d'instructions exécuté tant que la condition est vraie
}
while ( condition )
 Les aspects objets du langage
28

 Le langage java est un langage objet qui propose une classe de

base appelée : « java.lang.Object »

Toutes les classes java héritent

implicitement de java.lang.Object

 Pour connaître le type réel d'un objet on utilise l'opérateur «

instanceof ».

if ( obj instanceof maClasse )

// Bloc d'instructions
 Conversion de types
29

 La conversion de type ( « cast » ) est une technique fondamental

de la programmation :
 Pour convertir un type en un autre on respecte la syntaxe suivante :

( type de convervion ) type_a_convertir

 Attention la conversion est uniquement possible si le type à convertir est

lié au type de conversion.

 Exemple :

java.lang.Object obj = ( java.lang.Object ) new maClasse();

 Les types de base sous forme
30
objet
 Une série de classe sont définies pour encapsuler les types de bases :
 Short
 Integer
 Long
 Float
 Double
 Charactere
 Byte

 Chacune de ces classes proposes des opérations pour passer d'un

type à l'autre. Par exemple la classe « Integer » comporte les
opérations :
 intValue()
 shortValue()
 floatValue()
 Mise en place de paramètres en
31
sortie
public class Exemple
{
public void carre( IntConteneur val ) public class IntConteneur
{ {
val.valeur = val.valeur * 2; public int valeur;
} }
public static void main( String [] args )
{
Exemple ex = new Exemple();
IntContener val = new IntConteneur(2);
ex.carre( val );
System.out.println("Valeur au carré = " + val.valeur );
}
}
 L'opération « finalize »
32

 L'utilisation d'un garbage collector ne supprime pas l'intérêt d'utiliser un

destructeur ( rappel : un destructeur est une opération appelée
automatiquement à la destruction d'une instance ).

 L'opération « finalize » est appelée automatiquement par la machine

virtuelle au moment de la destruction de l'instance par le garbage collector.

protected void finalize()

{
// Code de finalize
}

 Il n'est pas obligatoire de fournir une opération « finalize ».

 Deux opérations sont à connaître :

 System.runFinalization();
 System.runFinalizersOnExit(true);
 Les tableaux (1)
33

 On peut définir un tableau sur tous les types java ( types primitifs,
classes, interfaces, tableaux ).

 Syntaxe de définition d'un tableau :

type [ ] nom;
type nom [ ];

 Un tableau est un objet qui contient un attribut indiquant sa taille : «

length »

int [ ] tab = new int[50];

System.out.println("Taille du tableau " + tab.length );
 Les tableaux (2)
34

 On peut fixer la taille avec toute variable (ou

expression) entière valorisée. Par exemple :

typeTab[] tab1, tab2 ; int taille = 10; tab1 = new

typeTab[taille] ; tab2 = new typeTab[tab1.length*2
+ 5] ;
 La propriété length très utile pour parcourir le
tableau à l'aide d'une boucle :

for (int i=0 ; i < tab.length ; i++)

System.out.println("tab["+i+"] = "+ tab[i]) ;
 Les tableaux (3)
35

 Un tableau en Java a toujours une taille fixée.

Si on a besoin d'une structure de taille

variable, il faut utiliser un objet Vector qui est
une sorte de liste chainée, de longueur non
limitée et dont les éléments de surcroit
peuvent être de type quelconque.
 Exemple
36

class Tableau {
public static void main(String[] args) {
int tabEntier[] = {1,5,9};
String[] joursOuvrables
={"lundi","mardi","mercredi","jeudi","vendredi"};
boolean tableau[]={true,false,true};
System.out.println("sommes nous le
"+joursOuvrables[3]+ tabEntier[0]+" ? c'est
"+tableau[1]);
}
}
 Tableaux d'objets
37

 voici la construction d'un tableau de 100 points :

Point[] points = new Point[100];
for (int i=0; i<100 ; i++)
points[i]= new Point();
for (int i=0; i<100 ; i++) {
points[i].x = (int) (Math.random()*100);
points[i].y = (int) (Math.random()*100);
}
 Tableaux à plusieurs dimensions
38

 Déclaration :
typeTab[] [] nomTab = new typeTab [taille1]
[taille2] ; int [] [] tabEntier2 = new int[10] [100] ;

A noter que les dimensions ne sont pas

forcément égales.
 Exemple
39

public class essaiTab {

static int [] [] tabEntier = { {1, 2 , 3 , 4, 5 },{ 45, 11 , 20 ,15 }, {41,
42, 43 } };
public static void main( String args[]) {
System.out.println("tabEntier [0] [1] = "+tabEntier [0] [1]);
System.out.println("tabEntier.length = "+tabEntier.length);
for (int i=0 ; i < tabEntier.length ; i++ )
System.out.println("tabEntier["+i+"].length ="+tabEntier[i].length);
}
}
 Copier un tableau
40

 Pour copier un tableau, on utilise l'opération « System.arraycopy »:

System.arraycopy( source, position, destination, position, nombre );

tableau source tableau destination nombre d'éléments

a copier
Index de départ Index de départ
pour le tableau source pour le tableau destination

 Exemple

System.arraycopy( liste, 0, tmp, 0, liste.length );

Le tableau de destination doit être alloué.
 Chaînes de caractères
41

 Les objets de la classe String ne sont pas des

tableaux de caractères en Java, comme c'est
le cas en C.
 Ce sont des objets à part entière, qui doivent
être déclarés et construits.
 Ils ont une taille fixée et définitive à leur
création.
 Si on veut traiter de chaînes de caractères
modifiables, il faut utiliser la classe
java.lang.StringBuffer.
 Constructions directes
42

 Construction normale
String ch = new String("Voici une chaine
!") ; System.out.println( ch ) ;
 Construction simplifiée
String ch = "Voici une chaine !" ;
 Reconstruction automatique
String ch = "Voici une chaine !" ;
System.out.println( ch ) ;
ch = "Bonjour !";
System.out.println( ch ) ;
 Autres schémas de construction
43

 byte[] table = {'B', 'o', 'n' , 'j' , 'o' , 'u' , 'r'} ;

String ch = new String(table, 0 , table.length) ;

 char[] table = {'a', 'b', 'c'};

String ch = new String( table );
equivalent à :String ch = "abc";
 Les méthodes de String
44

 ch.toUpperCase(); mise en majuscule de la chaine ch

 ch.length(); renvoie un entier, sa longueur
 ch.charAt(i); renvoie le ième caractère de ch, i variant de 0 à
ch.length()-1
 ch.indexOf('Z'); renvoie le rang de la première apparition de
'Z' dans ch, -1 sinon
 ch.indexOf("ava"); renvoie le rang de la première apparition
de "ava" dans ch, -1 sinon
 ch.substring(i, k); renvoie la sous-chaine extraite de ch, à
partir du rang i (le i+1 ème caractère)
jusqu'au rang k inclus.
 Les méthodes equals et
45
compareTo (1)
 Exemple
String r = "essai« ;
String s = "es" + "sai« ;
String u = "ESSAI".toLowerCase();
System.out.println(" (r == s) : " + (r == s));
System.out.println(" (r == u) : " + (r == u));
System.out.println(" r.equals(u) : " + (r.equals u));
 exécution
(r == s) : true
(r == u) : false
r.equals (u) : true
 Les méthodes equals et
46
compareTo (2)
 r == s : la valeur de cette expression (true) montre que les
références r et s sont ici égales
 r == u : cette expression vaut false ; les variables r et u
référencent deux instances différentes de la classe String
 r.equals(u) : cette expression vaut true; ici ce sont bien les
valeurs pointées par les références qui sont comparées.

 il ne faut donc pas tester l'égalité de deux chaînes avec "==",

mais utiliser la méthode equals() (ou bien la méthode
compareTo()).
 Classe StringBuffer (2)
47

 Il s'agit de créer des objets buffer ou zone de

travail qui contiennent des caractères.
 On réserve un buffer simplement en indiquant la
taille ou la valeur initiale, comme :
str=StringBuffer (128) ;
str=StringBuffer ("Bonjour ") ;
 La différence avec un objet String est que la taille
d'un StringBuffer est variable.
 Une telle chaine peut être modifiée et ainsi être
utilisée lors d'une construction dynamique.
 Classe StringBuffer (2)
48

 Méthodes spécifiques

append(ch) ajoute la chaine ch à la fin de

l'actuelle chaine
setLength(n) fixe la nouvelle longueur à n, ce
qui peut tronquer la chaine
actuelle.
 Remarque :
La concaténation + entre String est en fait
implémentée en utilisant StringBuffer et la
méthode toString().
 49

CONFIGURATION DE
L’ENVIRONNEMENT
 Distribution des applications java
50

 Tous les fichiers « .class » issus de la compilation peuvent être

rassemblés au sein d'un fichier d'archivage :
 soit de type ZIP
 soit de type JAR ( Java Archive )

 Pour créer une archive JAR, on utilise la commande « jar » qui est
similaire à la commande « tar » d'unix et qui prends à ce titre les
mêmes paramètres :

tar [xvfuct] nom_de_l'archive liste_de_fichiers

 Configuration de l’environnement
51

 Pour exécuter une application, la machine virtuelle java doit savoir où sont
stockées les classes à utiliser.

 Utilisation de la variable d'environnement « CLASSPATH ».

 Peut contenir des chemins absolus ou relatif,

 Peut énumérer des noms de fichiers ZIP ou JAR.

 A partir du JDK 1.2 il n'est plus nécessaire d'ajouter dans le CLASSPATH le

chemin des classes standards du JDK.
 Arborescence réelle des packages
52

 A l'issu de la compilation, un répertoire est créé pour chaque

package.

 Il en résulte une arborescence réelle à partir de l'arborescence

logique utilisée dans la programmation.

 La répertoire qui contient l'arborescence doit être placé dans le

variable d'environnement « CLASSPATH »
 Compilation d'une application java
53

 Pour compiler une application avec le JDK, on utilise l'utilitaire « javac ».

 Syntaxe de javac :
javac [ options ] nom_application

 Quelques options de cet utilitaire :

 -version : affiche le version du compilateur,

 -classpath : spécifie un CLASSPATH pour cette compilation,

 -sourcepath : spécifie un chemin ou sont contenus des fichiers java pouvant être
nécessaires à la compilation.
 Exécution d'une application java
54

 Pour exécuter une application java à partir du JDK, on doit emploi l'utilitaire
« java ».

 Syntaxe de « java »
java [ options ] nom_de_l'application.class arguments

 Options
 -Dxxxx=yyyyy : définie une variable d'environnement qui sera accessible pour un
programme,

 -cp : spécifie un CLASSPATH spécifique pour l'exécution.

 55

COMPLÉMENTS SUR JAVA

 Les entrées-sorties
56

 Le package « java.io » permet de gérer les opérations d’entrées /

sorties.

 Parmi les classes et interfaces du package « java.io » on distingue

essentiellement deux catégories :
 les entrées : dans ce cas, toutes les classes héritent de la classe
« java.io.InputStream »
 les sorties : ici c ’est « java.io.OutputStream ».

 Les entrés/sorties en java sont très simple à gérées et permettent

facilement d’utiliser l’écran, le clavier, les fichiers.
 Les classes
« java.io.InputStream » et
57
« java.io.OutputStream »

 « InputStream » une classe abstraite qui offre les prototypes

des méthodes pour toutes les opérations sur un flux d’entrée.

 « OutputStream » est également une classe abstraire

permettant des opérations sur un flux en sortie.

 Le flux d’entrée est quelconque ( clavier, fichier, socket ).

 Le flux de sortie est quelconque ( écran, fichier, socket )

 La classe
58
« java.io.BufferedOutputStream »
 Cette classe permet d’écrire dans un flux de sortie des séries
d’octets.

 Constructeur :
BufferedOutputStream( OutputStream out );

 Les principales opérations de cette classe sont :

 void write( byte [] buffer, int offset, int length );
 void flush();
 La classe
59
« java.io.BufferedInputStream »
 Permet la lecture de séries d’octet depuis un flux d’entrée.

 Constructeur :
BufferedInputStream( InputStream in )

 Les principales méthodes de cette classe sont :

 int read( byte [] buffer, int offset, int length );
 long skip( int n )
 void reset();
 La classe « java.io.PrintWriter »
60

 Cette classe permet d’écrire des informations dans un flux de sortie

( OutputStream ).

 Constructeurs :
PrintWriter( OutputStream out )
PrintWrtier( OutputStream out, boolean autoflush )

 Les principales méthodes de cette classe sont :

 void print( xxxx value ) : écrit une donnée de type xxxx ( xxxx est un des
types primitifs de java auxquels s’ajoutent String, Object )
 void println( xxxx value ) : même principe que « print » avec un retour à
la ligne après écriture.
 L’opération « toString »
61

 Lorsqu’un objet est passé à la méthode « print » ( ou « println » ),

l’opération « toString » de celui-ci est automatiquement appelée.

 Une opération « toString » est définie par défaut dans la classe

« java.lang.Object ».

 La signature de cette opération est :

public String toString()

 Les flux d’entrée et de sortie
62
standards
 Le flux d ’entrée standard est accessible depuis l ’attribut statique
« in » de la classe « java.lang.System ». Il s’agit d’un InputStream
qui symbolise par défaut le clavier.

 Il existe deux flux standards de sortie ( ces deux flux sont implantés
par des « PrintWriter » ):
 out : qui est un attribut statique de la classe « System » et qui par défaut
l’écran
 err : est également un attribut statique qui symbolise le flux de sortie
pour les erreurs ( par défaut, c’est également l’écran )
 Lecture et écriture de données
63

 Pour lire et écrire des données on utilise respectivement les classes

( définies dans le package java.io ) :
 DataInputStream
 DataOutputStream

 Ces classes offres des méthodes readXXX et writeXXX pour lire et

écrire des types primitifs java ainsi que UTF ( type String ).

 On crée une instance de ces classes à partir de InputStream et

OutputStream :
 DataInputStream( InputStream in )
 DataOutputStream( OutputStream out )
 Mise en œuvre des connaissances
64
!

 Ecrire une application qui lit depuis le flux

d’entrée standard une chaîne de
caractère et qui affiche à l’écran le
contenu de celle-ci.
 Les fichiers
65

 On peut facilement créer un fichier à partir de la classe

« java.io.File » :

 Pour écrire ou lire des données depuis un fichier, on utilise les

classes :
 java.io.FileInputStream
 java.io.FileOuputStream

 Ces classes jouent un rôle identique à « InputStream » et

« OutputStream » dont elles héritent.
 La classe « java.io.File »
66

 Les principales opérations de cette classe sont :

 boolean canRead()
 boolean canWrite()
 boolean delete()
 boolean exists()
 boolean isDirectory()
 boolean isFile()
 boolean renameTo( File dest )
 long length()
 boolean mkdir()
 boolean mkdirs()
 String getName( )
 Encore à vous...
67

 Cette fois-ci, il s’agit d’écrire une méthode qui lit le contenu

d’un fichier texte et qui affiche celui-ci à l ’écran.
 La classe « java.lang.String »
68

 La classe « String » permet la manipulation des chaînes de

caractères.

 Voici quelques unes des opérations les plus usitées de cette classe
:
 int length() : retourne la taille de la chaîne
 char CharAt(int index ) : retourne un caractère de la chaîne
 int hashCode() : retourne une code hash pour la chaîne
 String toUpperCase() : retourne une chaîne équivalente en majuscule
 String toLowerCase() : retourne une chaîne équivalente en minuscule
 boolean startsWith( String prefix ) : retourne « true » si la chaîne est
préfixée de la chaîne passée en paramètre
 boolean endsWith( String suffix ) : retourne « true » pour un suffixe
 Manipulation de chaîne de
69
caractères
 Des méthodes supplémentaires de la classe « java.lang.String »
permettent la manipulation des chaînes de caractères :
 String substring( int begin_index )
 String substring( int begin_index, int end_index )
 int indexOf( char c, int from_index )
 int indexOf( String s, int from_index )
 int lastIndexOf( char c )
 int lastIndexOf( String s )
 Vecteurs Java
70
 Contrairement aux tableaux, les objets
Vector sont des structures semblables aux
listes
 de dimension variable
 les éléments peuvent être des objets
quelconques (de types différents) .
 les éléments d'un vecteur contiennent
obligatoirement des références à des objets
 Il faut importer la classe Vector par import
java.util.Vector
 Construction
Vector liste = new Vector() ;
 Méthodes de gestion (1)
71
 void addElement(Object obj)
ajout d'un objet en fin de liste.
 boolean removeElement (Object obj)
suppression de l'élément si possible, renvoie
vrai ou faux selon.
 Object elementAt(int n)
retourne l'élément à la place spécifiée
 boolean contains(Object obj)
teste si l'objet spécifié appartient ou non au
vecteur.
 int indexOf(Object obj )
recherche et renvoie la 1ère occurrence de
l'objet, -1 si non trouvé
 Méthodes de gestion (2)
72

 int indexOf(Object obj , int n)

recherche et renvoie la 1ère occurrence
de l'objet à partir de la place n
 void removeElementAt(int n)
supprime l'élément numéro n.
 void removeAllElements()
supprime tous les éléments du vecteur.
 void insertElementAt(Object obj, int index)
insére l'objet à la place spécifiée
 int size() ; renvoie la taille actuelle du vecteur
 Encapsulation des types
73
primaires
 Exemple
Vector v = new Vector() ;
Integer un=new Integer(1);
v.addElement(un);
v.addElement(new Integer(2));
 à la rencontre d'une constante chaine, Java
construit lui-même un objet String
v.addElement("mercredi");
 Dictionnaires (Hashtable)
74

 structure de données permet d'associer à une

donnée appelée clé, une valeur unique qui
peut être n'importe quelle structure complexe.
 Construction
Hashtable dico = new Hashtable();
 Méthodes de gestion (1)
75
 Object put(Object cle, Object valeur)
permet d'ajouter au dico une association
supplémentaire clé-valeur qui peuvent être des
objets quelconques mais non null. l'objet renvoyé
est la précédente valeur associée à la clé ou null
sinon.
 Object remove(Object cle)
Supprime l'association du dico, si la cle est
trouvée sinon ne fait rien.
 Object get(Object cle)
Retourne la valeur à laquelle la clé est associée
ou null si la clé n'est pas trouvée.
 Enumeration keys()
Retourne une énumération des clés du dico
 Méthodes de gestion (2)
76  Enumeration elements()
Retourne une énumération des valeurs du dico. On utilise
ensuite les méthodes hasMoreElements() et nextElement()
pour la parcourir aisément séquentiellement.
 int size()
nombre de clés du dico
 boolean isEmpty()
Teste si le dico est vide ou non.
 boolean contains(Object valeur)
Teste si une certaine clé est associée dans le dico à la
valeur spécifiée.
 boolean containsKey(Object cle) Tests si la clé existe dans le
dico.
 Exemple
77

Enumeration e= dico.keys();
while (e.hasMoreElements())
{
String s= (String) e.nextElement();
System.out.println(s);
}