Utilisation de ArrayList

Dis comme ça, c'est un peu magique, je vais quand même préciser deux ou trois points :

La classe ArrayList est avant tout une liste, c'est à dire que les opérations de redimensionnement de la liste (ajout ou suppression d'un élément) sont prévues sans avoir à reconstruire complètement la liste.
ArrayList est construite en interne avec un tableau, ce qui a des avantages et des inconvénients, l'un des avantages est de pouvoir accéder immédiatement à ses éléments connaissant leurs indices, comme un tableau. L'un des inconvénients c'est que si on dépasse la capacité du tableau, celui-ci doit-être recréé, alors certes c'est transparent pour le développeur, mais ça a un coût non négligeable en terme de vitesse d'exécution.

"La taille est gérée automatiquement (elle double automatiquement à chaque fois que la moitié du max est atteinte, en commençant à 10 il me semble)"
En réalité, le redimensionnement n'a lieu que si le tableau est trop petit, c'est à dire quand le max est atteint, pas à sa moitié. Ensuite la taille du tableau n'est pas doublée, elle est agrandie de la moitié de la taille du tableau précédent. Par exemple si on a 10 (la capacité par défaut), l'ajout du 11è élément entraînera un redimensionnement à 15 (10+10/2), le 16è élément un redimensionnement à 22 (15+15/2), etc.

Par exemple pour l'insertion de 10000 éléments, avec une liste de capacité 10 par défaut, il sera nécessaire de redimensionner 18 fois le tableau (pour les 11è, 16è, 23è, 34è, 50è, 74è, 110è, 164è, 245è, 367è, 550è, 824è, 1235è, 1852è, 2777è, 4165è, 6247è et 9370è insertions).
C'est à dire qu'il y aura eu 19 tableaux créés en tout, qu'ils auront été copiés les uns dans les autres par transvasement, soit au total 28096 éléments copiés. Toutes ces opérations sont coûteuses, car elles ajoutent des opérations au programme que l'on peut éviter, si on utilise dès le départ le constructeur ArrayList(int) qui permet de préciser la capacité du tableau à prévoir. Par exemple pour 10000 éléments à insérer, on devrait au minimum mettre 10000 en paramètre, ainsi il n'y aura aucun redimensionnement et aucun copie de tableau avant d'insérer le 10001è élément.

"La recherche d'élément se fait via une fonction prédéfinie. Ce qui entraine que la modification des éléments dans la liste en est simplifié. "
Qu'est-ce que tu entends par là ?

"La gestion des suppression est automatique => Pas de trou comme dans un tableau simple"
Cela a encore un coût, car il n'y a rien de magique ! Si tu supprimes le premier élément d'une liste de 10000 éléments, alors les 9999 éléments suivants devront être déplacés un à un, ce qui allonge le temps du programme !! Là encore c'est transparent pour le développeur, il n'a pas à le gérer lui même, mais il ne faut oublier qu'au final c'est quand même fait quelque part...

Pour info, voici le code source de la classe ArrayList :
http://www.docjar.com/html/api/java/util/ArrayList.java.html

Pour répondre plus directement à elkadiri.wd, voici un exemple avec quelques méthodes à utiliser avec ArrayList :

// Création d'une liste d'hôtels, la liste est initialement prévue pour 100 hôtels
ArrayList<Hotel> liste = new ArrayList<Hotel>(100);

Hotel monHotel = ...

liste.add(monHotel); // ajout d'un hotel à la liste (à la fin)

int sz = liste.getSize(); // nombre d'hôtels dans la liste

monHotel = liste.get(2); // récupération du 3è hôtel de la liste

La liste complète des méthodes disponibles est dans la documentation :
https://docs.oracle.com/javase/7/docs/api/java/util/ArrayList.html

Pour la gestion de la taille, c'est ce qui m'a été apprit par mes profs (Chercheur en informatique à l'INRIA pour la plupart), donc je ne fais que reprendre ce qui m'a été apprit par des sources sûres...

La recherche : Je parle des méthodes get et indexOf, et pour la modification le set.

Je n'ai jamais dit que ces opérations n'était pas effectuées, loin de là. C'est juste ça ne se voit pas et c'est gérable très facilement comparé à un tableau.

"Pour la gestion de la taille, c'est ce qui m'a été apprit par mes profs"
Moi je me fie directement au code source de la classe ArrayList (en particulier la méthode grow), c'est la seule manière de savoir exactement ce que fais une classe.

La méthode get(i) ne fait que renvoyer le tableau [i] après quelques vérifications d'usages, il n'y a rien de plus compliqué que ça... idem pour set. Quant à indexOf, rien de magique il faut parcourir le tableau un à un, il n'y a pas de fonction prédéfinie qui simplifierai l'accès à ces éléments contrairement à d'autres structures de données (arbres, map, etc.)

"Je n'ai jamais dit que ces opérations n'était pas effectuées, loin de là"
Ok, on est d'accord alors, mais il faut toujours insister sur leurs coûts, en particulier celui du redimensionnement quand la capacité n'est pas suffisante, parce que c'est le gros point faible de cette structure de donnée !

C'est certes plus fiable, tu as probablement raison, mais je n'ai pas le temps de vérifié tout ce qui est dit :)

Oui c'est un simple parcours de tableau, mais pour ceux qui ne sont pas à l'aise avec les algorithmes, c'est toujours un cadeau, même si ce type d'algo n'a rien de bien compliqué :)

Certes, mais je ne pense pas qu'il ai de problème pour la gestion d'un hôtel, il n'y a pas des milliers de données à gérer chaque seconde... :)

Si tu veux vérifier, je me suis surtout intéressé à ces trois méthodes :

  410       public boolean add(E e) {
  411           ensureCapacityInternal(size + 1);  // Increments modCount!!
  412           elementData[size++] = e;
  413           return true;
  414       

  183       private void ensureCapacityInternal(int minCapacity) {
  184           modCount++;
  185           // overflow-conscious code
  186           if (minCapacity - elementData.length > 0)
  187               grow(minCapacity);
  188       }

  204       private void grow(int minCapacity) {
  205           // overflow-conscious code
  206           int oldCapacity = elementData.length;
  207           int newCapacity = oldCapacity + (oldCapacity >> 1);
  208           if (newCapacity - minCapacity < 0)
  209               newCapacity = minCapacity;
  210           if (newCapacity - MAX_ARRAY_SIZE > 0)
  211               newCapacity = hugeCapacity(minCapacity);
  212           // minCapacity is usually close to size, so this is a win:
  213           elementData = Arrays.copyOf(elementData, newCapacity);
  214       }

Pour l'ajout on a ensureCapacity(size + 1); qui implique qu'on augmentera la taille au moment où celle ci sera dépassée, si on l'augmentait à la moitié du remplissage on aurait eu ensureCapacity(size << 1);

Et au niveau du grow, on a cette ligne : newCapacity = oldCapacity + (oldCapacity >> 1); qui implique bien une augmentation de la taille du tableau de la moitié du tableau actuel.

"pour ceux qui ne sont pas à l'aise avec les algorithmes, c'est toujours un cadeau"
C'est un peu le principe de la POO, ne pas refaire ce qui existe déjà !!

"je ne pense pas qu'il ai de problème pour la gestion d'un hôtel, il n'y a pas des milliers de données à gérer chaque seconde"
C'est toujours important d'essayer d'utiliser les classes au mieux de leurs potentiels (je pense en particulier à la création en précisant la taille du tableau) et de se poser quelques questions pour savoir s'il n'y a pas une classe qui serait meilleure qu'une autre pour faire une opération... Un développeur qui utilise toujours ArrayList parce qu'il n'a appris que ça en cours, ce n'est clairement pas suffisant !

Tout dépend ce que tu veux faire, pour l'instant tu nous parles de ta base de données et des actions que tu as fait sur la base de données, mais parles nous plutôt des actions que tu as besoin de faire avec ton programme Java, c'est là que les ArrayList interviendront.

Comme ça, sans informations utiles, je dirais que les ArrayList pourraient être utilisées par exemple au fur et à mesure que tu lis ton ResultSet, chaque résultat de ta requête étant stocké dans la liste, mais il faut voir à quoi ça te servirait.

Dans tous les cas une liste n'est utile que si tu as plusieurs objets à mettre dedans, si tu ajoutes modifies ou supprime un seul client tu n'as pas besoin d'utiliser de liste...

Par exemple si on veux afficher la liste des client dans JTable, ArrayList ne devrait pas etre utilisée?

Dans ce cas là, si, mais tu n'en as pas parlé lorsque tu as "détaillé" ton problème ! Il faut absolument que tu détailles ce que tu veux faire, code à l'appui, parce que sinon on ne va pas pouvoir t'aider !

"on veux afficher la liste des client"
Déjà rien que dans ta phrase il y a le mot "liste" qui apparaît, c'est là qu'intervient l'ArrayList.
On est dans le cas dont je parlais tout à l'heure, tu vas avoir un ResultSet qui va contenir plusieurs résultats que tu vas ajouter au fur et à mesure dans ta liste. Tu te serviras ensuite de cette liste pour faire tous les traitements qui pourraient être utiles à l'affichage, et une fois ce traitement terminé tu afficheras le résultat sur ton IHM.

merci beaucoup :)