Tableaux arraylist

Introduction

• Dans la programmation, il est essentiel de gérer des collections d'éléments.

• En Java, deux structures couramment utilisées sont les tableaux (arrays) et les ArrayList.

• Bien que similaires, elles diffèrent sur plusieurs points : gestion de la taille, flexibilité, types de données, méthodes disponibles.

Les Tableaux en Java

• Définition: Les tableaux sont des structures de données de taille fixe pour stocker des éléments du même type.

• La taille d'un tableau est fixée lors de sa création et ne peut pas être modifiée.

2.1 Déclaration d’un tableau

• Syntaxe de déclaration: type[] nom = new type[taille];

• Exemple: int[] nombres = new int[5]; (tableau capable de stocker 5 entiers)

2.2 Affectation des éléments

• Utilisation de l'index pour assigner des valeurs :

  • nombres[0] = 10;

  • nombres[1] = 20;

2.3 Accès aux éléments

• Accès via l'indice : int premierNombre = nombres[0];

2.4 Valeurs par défaut

• Les cases d'un tableau sont initialisées avec des valeurs par défaut selon leur type:

  • int : 0; boolean : false; objet : null.

2.5 Parcourir un tableau avec une boucle for

• La boucle for est couramment utilisée pour itérer à travers un tableau:

  • Exemple :

    for (int i = 0; i < nombres.length; i++) {
        System.out.println("élément d'indice " + i + " : " + nombres[i]);
    }

2.6 Tableaux et références

• Les tableaux sont semblables aux objets mais n'ont pas de méthodes ni de constructeurs.

• Création avec new, stockés dans le tas, références contiennent l'adresse.

Les ArrayList en Java

• Définition: Les ArrayList permettent de stocker des éléments de manière dynamique.

• Contraste: Taille flexible, mais ne peut contenir que des objets (utilisation de classes wrapper pour types primitifs).

3.1 Création d’une ArrayList

• Déclaration : ArrayList<Type> nom = new ArrayList<>();

• Exemple : ArrayList<Integer> nombres = new ArrayList<>();

3.2 Ajout d’un élément

• Ajouter un élément avec la méthode add():

  • nombres.add(10);

3.3 Accès à un élément

• Accéder à un élément avec get():

  • Integer premierNombre = nombres.get(0);

3.4 Quelques méthodes utiles

• Méthodes pratiques incluent:

  • add(E element): Ajoute un élément.

  • get(int index): Récupère l'élément.

  • set(int index, E element): Modifie l'élément.

  • remove(int index): Supprime l'élément.

  • size(): Renvoie la taille.

  • contains(Object o): Vérifie la présence d'un élément.

  • clear(): Supprime tous les éléments.

3.5 Exemple d’utilisation des méthodes

• Exemple d'utilisation de méthodes sur une ArrayList:

  ArrayList<Integer> nombres = new ArrayList<>();
  nombres.add(10);
  nombres.add(20);
  Integer secondNombre = nombres.get(1); // 20
  nombres.set(1, 25); // Replace 20 with 25
  boolean contientDix = nombres.contains(10); // true
  nombres.remove(0); // Supprime le premier élément (10)
  int taille = nombres.size(); // 2 (après suppression)

3.6 Parcourir une ArrayList avec une boucle for

• Utilisation d'une boucle for pour parcourir:

  for (int i = 0; i < nombres.size(); i++) {
      System.out.println(nombres.get(i));
  }

La boucle foreach en Java

• Permet de parcourir des collections sans gérer les indices manuellement.

4.1 Utilisation de foreach avec les tableaux

• Exemple sur les tableaux:

  for (int nombre : nombres) {
      System.out.println(nombre);
  }

4.2 Utilisation de foreach avec les ArrayList

• Exemple avec ArrayList:

  for (Integer nombre : nombres) {
      System.out.println(nombre);
  }

4.3 La boucle foreach avec d’autres types de collections

• Fonctionne avec tout objet qui implémente l’interface Iterable.

4.4 Avantages de la boucle foreach

• Avantages incluent simplicité, sécurité et compatibilité.

Comparaison des tableaux et des ArrayList

• Taille:

  • Tableaux : fixe.

  • ArrayList : dynamique.

• Type de données stockées:

  • Tableaux : primitifs et objets.

  • ArrayList : objets uniquement.

• Méthodes associées:

  • Tableaux : pas de méthodes.

  • ArrayList : dispose de plusieurs méthodes utiles.

• Flexibilité:

  • Tableaux : rigides.

  • ArrayList : très flexibles.

Tableaux et ArrayList à deux dimensions ou plus

• Possible de créer des tableaux et des ArrayList multidimensionnels.

6.1 Tableaux à deux dimensions

• Création : int[][] tableau = new int[3][3];

• Parcours avec boucle imbriquée.

6.2 ArrayList à deux dimensions

• Création d’une ArrayList contenant d'autres ArrayList.

Exemples typiques d’utilisation des tableaux et des ArrayList

• Tableaux: adaptées pour les listes fixes (ex: noms des mois).

• ArrayList: idéales pour gérer des listes dynamiques (ex: liste de produits).

Conclusion

• Exploration des tableaux et ArrayList en Java.

• Comparaison de leurs caractéristiques, avantages et usages typiques:

  • Les tableaux sont fixés, optimaux pour un accès performant.

  • Les ArrayList sont flexibles, idéales pour des données dynamiques.