Données en Java - Nicolas Zinovieff

Donn´ees en Java
Nicolas Zinovieff
15 janvier 2007
La documentation Java se trouve `a l’adresse suivante : http ://java.sun.com/javase/reference/index.jsp

TABLE DES MATI ` ERES 2TABLE DES MATI ` ERES
Table des mati`eres
1 M´emoire 3
1.1 Valeurs, Variables, et Cases M´emoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.1 ScalairesetConversions ..................................... 3
1.1.2 PointeursetObjets ....................................... 3
1.1.3 Verslesstructures ........................................ 3
1.2 Structuresetobjets ........................................... 3
1.2.1 Variablesd’instance ....................................... 3
1.2.2 M´ethodesd’instance ....................................... 4
1.2.3 Accesseurs............................................. 5
1.2.4 Variables et m´ethodes de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3 Tableaux ................................................. 5
1.3.1 Partirdecequ’onconnaˆıt.................................... 5
1.3.2 Uneentit´e´etrange ........................................ 6
1.3.3 D´esavantages ........................................... 6
1.4 Vector................................................... 6
1.4.1 Utilisationetsyntaxe ...................................... 6
1.4.2 Avantagesetpr´ecautions .................................... 7
1.5 Listes,Piles,Files ............................................ 7
1.6 Matrices.................................................. 7
1.6.1 Matrices`ataillefixe ....................................... 7
1.6.2 Matrices`ataillevariable..................................... 7
1.7 Dictionnaire................................................ 8
1.7.1 UtilisationetSyntaxe ...................................... 8
1.7.2 Avantagesetpr´ecautions .................................... 8
2 Fichiers / Echanges 8
2.1 Syst`emedefichiers............................................ 8
2.1.1 Abstraction............................................ 9
2.1.2 Op´erations sur les dossiers et fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2 Lecture et ´ecriture des donn´ees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2.1 Principes ............................................. 9
2.2.2 Unexemple............................................ 10
2.2.3 Exceptions ............................................ 10
2.2.4 Formats.............................................. 11
2.3 S´erialisation................................................ 11
2.3.1 Principe.............................................. 11
2.3.2 Avantagesetinconv´enients ................................... 11
2.3.3 Utilisationetsyntaxe ...................................... 12
2.4 R´eseau................................................... 12
2.4.1 Principe.............................................. 12
2.4.2 Socket............................................... 12
2.4.3 Protocoles............................................. 13
La documentation Java se trouve `a l’adresse suivante : http ://java.sun.com/javase/reference/index.jsp

31 M ´ EMOIRE
1 M´emoire
Dans un premier temps, nous allons nous int´eresser au stockage des donn´ees semi-permanent : le temps de
l’ex´ecution de votre programme, vous devez vous rappeler d’un certain nombre de choses, allant de la variable
temporaire pour une m´ethode jusqu’`a la liste de toutes les actions effectu´ees depuis le lancement du programme.
Ce stockage semi permanent est fait en m´emoire, qui est souvent la mˆeme chose que la RAM. Lorsque votre
programme quitte, ces informations sont perdues.
1.1 Valeurs, Variables, et Cases M´emoires
1.1.1 Scalaires et Conversions
A la grande diff´erence de langages comme le C, l’acc`es direct `a la m´emoire est interdit. Prenons une d´eclara-
tion : int32 a= 10 En C, cela revient `a d´efinir une case m´emoire de 32 bits de long, contenant la valeur 10. Que
signifie int32 dans ce contexte ? La partie int est surtout pour le programmeur. En effet, si vous faites double b =
(double)a, le comportement n’est pas d´efini. Ou bien on a une conversion, ou bien on a une r´einterpr´etation des
octets. En Java, l’acc`es m´emoire est interdit, le langage est fortement typ´e. Lorsque vous d´eclarez une variable
comme ´etant un int, un float ou un char, son type est important. Un cast en Java est forc´ement une conversion.
1.1.2 Pointeurs et Objets
En Java, puisque l’acc`es direct `a la m´emoire est interdit, il n’y a aucun pointeur. Les scalaires sont stock´es
dans leurs cases m´emoire, et ne peuvent pas ˆetre partag´es. Ce qui s’en rapproche le plus, ce sont les objets.
D’apr`es ce que l’on a vu pr´ec´edemment, il s’agit d’une collection de variables et de m´ethodes. Pour stocker une
telle collection, il faut donc une allocation dynamique. On peut donc d´ecemment supposer que new cache en
fait un malloc. Un autre indice conforte cette hypoth`ese :
int a,b;
a = 5;
b = a;
a = 3;
Dans ce cas, `a la fin, a vaut 3 et b vaut 5. Mais si, `a supposer que Entier repr´esente la classe des entiers, et
qu’elle utilise comme variable interne n, on prend :
Entier a,b;
a = new Entier(5);
b = a;
a.n = 3;
Dans ce cas, a et b contiennent la valeur 3. Autrement dit, a et b sont des pointeurs sur la mˆeme structure.
Il faut garder `a l’id´ee cet effet secondaire, tout en sachant qu’en pratique, vos objets ne pourront jamais tout `a
fait ˆetre manipul´es comme des pointeurs.
1.1.3 Vers les structures
Comme on l’a vu dans l’exemple pr´ec´edent, un objet est un “pointeur sur une collection de variables et
de m´ethodes”. Une structure en C est une fa¸con d’agencer un certain nombre de valeurs dans un mˆeme bloc
m´emoire. On peut facilement voir que l’objet est une esp`ece de “super-structure” qui contient `a la fois :
– une s´erie de variables, comme dans une struct
– une s´erie de fonctions qui ont un impact sur ces variables
– des informations sur la classe dont est issu cet objet (type, h´eritage, m´ethodes des superclasses, etc)
Qu’est-ce qui nous empˆeche d’utiliser ces objets comme des structures de stockage ?
1.2 Structures et objets
1.2.1 Variables d’instance
Imaginons la structure C suivante :
La documentation Java se trouve `a l’adresse suivante : http ://java.sun.com/javase/reference/index.jsp

1.2 Structures et objets 41 M ´ EMOIRE
struct {
int a;
float b;
double c;
} collection;
Cette structure peut s’utiliser comme suit :
struct collection t;
t.a = 0;
t.b = 10.0f;
t.c = 3.1416;
En Java, il est possible d’avoir exactement le mˆeme comportement avec des objets. On appelle ce m´ecanisme
l’encapsulation.
class Collection {
int a;
float b;
double c;
}
Et on l’utilise comme suit :
Collection t = new Collection(); // ‘‘malloc’’
t.a = 0;
t.b = 10.0f;
t.c = 3.1416;
Cette encapsulation permet d’associer au sein d’une mˆeme structure toutes les informations utiles `a un
moment donn´e. Pour une connexion `a un serveur, par exemple, l’objet contiendrait `a la fois l’adresse du serveur,
le port sur lequel on se connecte, le port local associ´e, et les buffers d’entr´ee/sortie. D`es lors qu’on aimerait avoir
une structure, on utilise une classe d’encapsulation.
1.2.2 M´ethodes d’instance
Mais `a part un regroupement, quel est l’int´erˆet de garder une variable dans une classe d’encapsulation ? On
pourrait reprendre l’exemple de l’entier. On a une classe qui contient un int.
class Entier {
int n;
}
Pourquoi se fatiguer ? Plusieurs raisons `a cela :
– les fonctions n’existent pas dans la nature. Toute fonction ou m´ethode est forc´ement d´eclar´ee et impl´e-
ment´ee dans une classe. Donc un endroit intelligent pour mettre des m´ethodes se rapportant aux entiers
serait la classe Entier.
– on pousse jusqu’au bout le raisonnement de l’abstraction. On a beau dire que les acc`es m´emoire sont
interdits, il n’empˆeche qu’un int a une taille fixe. Laquelle ? on ne la connait pas, mais elle existe. Si on
d´efinit une classe Entier avec toutes les m´ethodes habituelles li´ees aux entiers (additions, soustractions,
etc...), la taille maximale de l’entier devient le probl`eme de celui qui con¸coit la classe, pas de celui qui
l’utilise. Et si un jour le concepteur trouve que c’est une bonne id´ee de changer la repr´esentation interne
de l’entier, en mettant par exemple un long, rien ne changera du point de vue de l’utilisateur.
– les objets sont des “pointeurs”. Par cons´equent, on peut simuler un passage par adresse, et modifier l’objet
pass´e en param`etre de la m´ethode, ou bien partager un objet entre plusieurs bouts de programme qui
peuvent y stocker les informations communes (comme les pr´ef´erences d’une application, par exemple)
La documentation Java se trouve `a l’adresse suivante : http ://java.sun.com/javase/reference/index.jsp

1.3 Tableaux 51 M ´ EMOIRE
1.2.3 Accesseurs
Un des premiers exemples de m´ethodes d’instance, c’est l’accesseur. En effet, un acc`es direct aux variables
comme dans les exemples pr´ec´edents marche, mais est relativement peu sˆur pour les gros objets, et mˆeme si
c’est plus court, on consid`ere que c’est stylistiquement peu appr´eciable.
Ces accesseurs sont aussi appel´es les get/set. On s’en sert pour contrˆoler l’acc`es aux variables. En effet, comme
ce sont des m´ethodes, on peut y mettre des conditions, des temps d’arrˆet en cas d’acc`es concurrents, etc... Ils
prennent g´en´eralement la forme suivante :
class Entier {
private int nombre; // on emp^eche l’acc`es direct
public int getNombre() {
return nombre;
}
public void setNombre(int p) {
nombre = p;
}
}
1.2.4 Variables et m´ethodes de classe
Il existe des fois o`u on aimerait des variables partag´ees dans tout le programme (pensez globales, mais
pas trop fort, c’est parfois consid´er´e comme une insulte). Une variable ainsi partag´ee ne peut pas exister dans
l’absolu, au mˆeme titre que les m´ethodes. On les d´eclare donc dans une classe pr´ecise, et on dit qu’elles sont
ind´ependantes de l’instance consid´er´ee. Par exemple, la valeur maximale d’un int ne d´epend pas de l’entier
concern´e...
On les d´eclare donc static, et on y fait r´ef´erence en parlant de la classe :
class Entier {
static int MAX_INT = 2147483647;
(...)
}
// et ailleurs
int a = ...
if(a < Entier.MAX_INT) {
...
}
Il en va de mˆeme pour les m´ethodes. Toute m´ethode “globale”, qui ne d´epend absolument pas d’une instance
particuli`ere pour marcher est d´efinie en static. Par exemple, toutes les m´ethodes de trigonom´etrie sont des
m´ethodes static de la classe Math. En effet, elles prennent en param`etres des scalaires, et ne d´ependent d’aucun
object pour fonctionner. La plupart des fonctions purement utilitaires sont souvent statiques.
C’est la raison pour laquelle le main doit n´ecessairement ˆetre static : avant de cr´eer le moindre objet (c’est
la premi`ere m´ethode appel´ee !), on ne peut appeler que des m´ethodes de classe.
1.3 Tableaux
1.3.1 Partir de ce qu’on connaˆıt
Lorsqu’on cherche `a stocker une s´erie d’instances, le r´eflexe traditionnel est d’invoquer le tableau. Celui ci
permet de faire r´ef´erence `a un grand nombre d’instances, g´en´eralement inconnu au d´epart, par des indexes au
lieu de variables locales. En C, on d´eclare un tableau comme suit :
int tab[taille];
Cela alloue un tableau contenant taille entiers. En Java, le principe est similaire, mais les allocations dynamiques
doivent toutes se faire par l’interm´ediaire de new. On le d´eclare donc sans taille, et on passe ce param`etre au
moment du new :
La documentation Java se trouve `a l’adresse suivante : http ://java.sun.com/javase/reference/index.jsp