# Programmation Java/Tableaux

* Introduction
* La notion de machine virtuelle
* Installation
** NetBeans
** Eclipse
** Visual Studio Code
* Bases du langage
** Premier programme
** Commentaires
** Types de base
** Opérateurs
** Conditions
** Bloc de portée
** Itérations
** Tableaux
* Les classes en Java
** Membres
** Modificateurs d'accès
** Héritage
** Encapsulation
** Polymorphisme
** Classes abstraites
** Interfaces
** Classes internes
** Transtypage
** Types génériques
** Instanciation et cycle de vie
** « this »
** Objets comparables et clés
** Énumérations
** Exceptions
** Packages
* Classes de base
** Collections
** Nombre de taille arbitraire
** Tags Javadoc
** Annotations
** Entrées sorties
** Threads et synchronisation
** Méthodes natives
** Réflexion
** Regex
** JUnit
* Conclusion
* Exemples en Java
** Générer un carré magique
** Générer un triangle de Sierpiński
** XML
** Swing
*** Un premier exemple
*** Formulaire avec boutons sur image
*** Calcul de somme
*** Calcul de distance
* Annexes
** Les outils de base fournis avec le Java Development Kit
** Créer une archive Java
** Paramétrer la JVM
** Liste des mots réservés
** Débogage
** Java et les autres langages
* Introduction
* La notion de machine virtuelle
* Installation
** NetBeans
** Eclipse
** Visual Studio Code
* Bases du langage
** Premier programme
** Commentaires
** Types de base
** Opérateurs
** Conditions
** Bloc de portée
** Itérations
** Tableaux
* Les classes en Java
** Membres
** Modificateurs d'accès
** Héritage
** Encapsulation
** Polymorphisme
** Classes abstraites
** Interfaces
** Classes internes
** Transtypage
** Types génériques
** Instanciation et cycle de vie
** « this »
** Objets comparables et clés
** Énumérations
** Exceptions
** Packages
* Classes de base
** Collections
** Nombre de taille arbitraire
** Tags Javadoc
** Annotations
** Entrées sorties
** Threads et synchronisation
** Méthodes natives
** Réflexion
** Regex
** JUnit
* Conclusion
* Exemples en Java
** Générer un carré magique
** Générer un triangle de Sierpiński
** XML
** Swing
*** Un premier exemple
*** Formulaire avec boutons sur image
*** Calcul de somme
*** Calcul de distance
* Annexes
** Les outils de base fournis avec le Java Development Kit
** Créer une archive Java
** Paramétrer la JVM
** Liste des mots réservés
** Débogage
** Java et les autres langages
[ Modifier le sommaire ]
Un tableau est un ensemble indexé de données d'un même type. L'utilisation d'un tableau se décompose en trois parties :
* Création du tableau ;
* Remplissage du tableau ;
* Lecture du tableau.

## Création d'un tableau

Un tableau se déclare et s'instancie comme une classe :
ou
L'opérateur [ ] permet d'indiquer qu'on est en train de déclarer un tableau.
Dans l'instruction précédente, nous déclarons un tableau d'entiers (int, integer) de taille 10, c'est-à-dire que nous pourrons stocker 10 entiers dans ce tableau.
Si [ ] suit le type, toutes les variables déclarées seront des tableaux, alors que si [ ] suit le nom de la variable, seule celle-ci est un tableau :
Dans ces quatre déclarations, seule variable n'est pas un tableau.

## Remplissage d'un tableau

Une fois le tableau déclaré et instancié, nous pouvons le remplir :
L'indexation démarre à partir de 0, ce qui veut dire que, pour un tableau de N éléments, la numérotation va de 0 à N-1.
Dans l'exemple ci-dessus, la 6ème case contient donc la valeur 23.
Nous pouvons également créer un tableau en énumérant son contenu :
Ce tableau contient 5 éléments.
Lorsque la variable est déjà déclarée, nous pouvons lui assigner d'autres valeurs en utilisant l'opérateur new :

## Lecture d'un tableau

Pour lire ou écrire les valeurs d'un tableau, il faut ajouter l'indice entre crochets ([ et ]) à la suite du nom du tableau :
L'indice 0 désigne le premier élément du tableau.
L'attribut length d'un tableau donne sa longueur (le nombre d'éléments). Donc pour un tableau nommé monTableau l'indice du dernier élément est monTableau.length-1.
Ceci est particulièrement utile lorsque nous voulons parcourir les éléments d'un tableau.

## Parcours des tableaux

Java 5 fournit un moyen plus court de parcourir un tableau.
L'exemple suivant réalise le traitement sur monTableau (tableau d'entiers) :
Attention néanmoins, la variable élément contient une copie de monTableau[i]. Avec des tableaux contenant des variables primitives, toute modification de élément n'aura aucun effet sur le contenu du tableau.
Pour éviter de modifier la variable, utilisez le mot-clé final :

## Tableaux à plusieurs dimensions

En Java, les tableaux à plusieurs dimensions sont en fait des tableaux de tableaux.
Exemple, pour allouer une matrice de 5 lignes de 6 colonnes :
Java permet de résumer l'opération précédente en :
La première version montre qu'il est possible de créer un tableau de tableaux n'ayant pas forcément tous la même dimension.
On peut également remplir le tableau à la déclaration et laisser le compilateur déterminer les dimensions des tableaux, en imbriquant les accolades :
Pour déterminer la longueur des tableaux, on utilise également l'attribut length :
De la même manière que précédemment, on peut facilement parcourir tous les éléments d'un tableau :
Depuis Java 5, il est possible de parcourir les valeurs comme ceci :
Le parcours des éléments du tableau row peut également utiliser la boucle for itérative sur le type primitif int. Ce type de boucle ne permet pas de modifier les éléments du tableau.
Pour une matrice d'objet, cela est donc également possible :

## La classe Arrays

La classe Arrays du package java.util possède plusieurs méthodes de gestion des tableaux de types de base, et d'objets :
* la méthode asList convertit un tableau en liste,
* la méthode binarySearch effectue la recherche binaire d'une valeur dans un tableau,
* la méthode equals compare deux tableaux renvoie un booléen true s'ils ont même longueur et contenu,
* la méthode fill remplit un tableau avec la valeur donnée,
* la méthode sort trie un tableau dans l'ordre croissant de ses éléments.
Par défaut, Arrays.sort place les caractères non ASCII après le "z" (ex : à, é...). Pour tenir compte de l'Unicode, il faut donc utiliser son deuxième paramètre : un java.text.Collator ou un java.util.Comparator.

## Copie d'un tableau

La copie d'un tableau implique la copie de ses éléments dans un autre tableau. Dans le cas d'un tableau d'objets, seules les références à ces objets sont copiées, aucun nouvel objet n'est créé.
La méthode arraycopy de la classe System permet de copier tout ou partie d'un tableau vers un autre tableau déjà alloué.
Comme toutes les classes, les tableaux dérivent de la classe java.lang.Object. Les méthodes de la classe Object sont donc utilisables :
La copie intégrale d'un tableau dans un nouveau tableau peut donc se faire en utilisant la méthode clone. La valeur retournée par cette méthode étant de type Object, il faut la convertir dans le type concerné.
Exemple :

## Modifier la taille et copier une partie

La taille d'un tableau est fixe, mais il est possible d'allouer un autre tableau avec une taille différente et de recopier une partie des éléments du tableau d'origine. Cela peut se faire manuellement, ou en utilisant les méthodes existantes de la classe java.util.Arrays.

### Arrays.copyOf(T original, int nouvelle_taille)

    Retourne un nouveau tableau de la taille spécifiée rempli avec les éléments du tableau original. Si la taille est plus petite, les derniers éléments ne sont pas copiés. Si la taille est plus grande, la fin du nouveau tableau est remplie par l'élément nul du type des éléments : false pour boolean, 0 pour les types numériques, null pour tous les autres types (tableau, chaîne, objet, ...).
Une autre méthode permet de copier une portion d'un tableau en spécifiant un index de début et un index de fin. Cet index de fin peut aller au delà de la taille du tableau original, auquel cas les derniers éléments du nouveau tableau sont remplis par l'élément nul du type des éléments, comme pour la méthode précédente.

### Arrays.copyOfRange(T original, int index_début, int index_fin)

    Retourne un nouveau tableau dont la taille est la différence entre les deux indexs, rempli avec les éléments du tableau original dont l'indice est compris entre l'index de début (inclus) et celui de fin (exclu).

## Comparaison de deux tableaux
### Référence

Une variable de type tableau étant de type référence, l'utilisation des opérateurs de comparaison == et != ne font que comparer les références. Ils ne permettent pas de détecter des références à deux tableaux différents mais dont la taille et le contenu est le même (éléments dans le même ordre).

### Contenu identique (éléments dans le même ordre)

Pour tester si deux tableaux ont la même taille et les mêmes éléments à la même position, le plus simple est d'utiliser la méthode statique equals de la classe java.util.Arrays. Cette méthode est en fait surchargée pour supporter les éléments de tous les types primitifs et des types références (objets).

### Éléments communs et particuliers

Il serait possible de lancer des boucles de comparaison, mais le plus court moyen donne un avant-goût du chapitre Collections. Le code ci-dessous établit, à partir de deux tableaux de chaînes de caractères, la liste des éléments communs aux deux et la liste des éléments particuliers à chaque tableau.

## Nouvelle allocation d'un tableau de grande taille

Certaines applications ont besoin de beaucoup de mémoire et alloue beaucoup de ressources. Par exemple, un éditeur de vidéos peut garder en mémoire plusieurs images sous la forme d'un tableau de pixels pour modifier une séquence vidéo.
Dans une telle situation, la limite mémoire est souvent atteinte. Supposons que l'application ait alloué un tableau de pixels pour une opération qui vient de se terminer, et qu'un nouveau tableau de pixels de taille différente soit nécessaire pour la suite du traitement.
Au moment de la seconde allocation, il est nécessaire que la quantité de mémoire disponible soit suffisante pour la taille du nouveau tableau. Durant l'allocation du second tableau, le premier tableau n'est pas libéré : l'opération new est effectuée avant l'assignation qui écrase la référence au premier tableau.
Afin d'éviter un problème de quantité de mémoire disponible insuffisante, il est recommandé d'assigner null à la référence au premier tableau (et à toutes les autres références à ce même tableau) afin que le ramasse-miettes puisse libérer ce tableau si besoin.