En Java, un tableau (array) est une structure de données qui peut stocker un nombre fixe d’éléments du même type. Les éléments d’un tableau sont stockés en mémoire de manière contiguë et peuvent être accédés en utilisant leur indice (la position de l’élément dans le tableau).

Voici comment vous pouvez déclarer, créer et initialiser des tableaux en Java :

  1. Déclaration d’un tableau : Vous pouvez déclarer un tableau en spécifiant son type et en utilisant des crochets [].
int[] monTableau;
  1. Création d’un tableau : Vous pouvez créer un tableau en utilisant le mot-clé new suivi du type et de la taille du tableau.
monTableau = new int[10];
  1. Initialisation d’un tableau : Vous pouvez initialiser un tableau au moment de sa création.
int[] monTableau = {1, 2, 3, 4, 5};
  1. Accès aux éléments d’un tableau : Vous pouvez accéder à un élément d’un tableau en utilisant son indice. Les indices de tableau en Java commencent à 0.
int premierElement = monTableau[0];
  1. Modification des éléments d’un tableau : Vous pouvez modifier un élément d’un tableau en utilisant son indice.
monTableau[0] = 10;
  1. Obtenir la taille d’un tableau : Vous pouvez obtenir la taille (le nombre d’éléments) d’un tableau en utilisant la propriété length.
int taille = monTableau.length;

Il est important de noter que la taille d’un tableau en Java est fixe. Une fois qu’un tableau est créé, vous ne pouvez pas changer sa taille. Si vous avez besoin d’une structure de données de taille variable, vous pouvez utiliser des classes comme ArrayList qui font partie du framework Collections en Java.

 

Les ArrayList (Collection)

Les ArrayList en Java sont des structures de données dynamiques qui peuvent contenir un nombre variable d’éléments. Contrairement aux tableaux, les ArrayList peuvent changer de taille pendant l’exécution du programme. Les ArrayList sont implémentées en tant que classes dans la bibliothèque standard Java et peuvent être utilisées pour stocker des données de n’importe quel type (primitif ou objet).

Voici un exemple de code qui montre comment créer et utiliser une ArrayList en Java:

 

import java.util.ArrayList;

public class ExempleArrayList {
    public static void main(String[] args) {
        // Création d'une ArrayList
        ArrayList<String> fruits = new ArrayList<String>();

        // Ajout d'éléments
        fruits.add("Pomme");
        fruits.add("Banane");
        fruits.add("Orange");

        // Accès aux éléments
        String premierFruit = fruits.get(0);
        System.out.println("Premier fruit: " + premierFruit);

        // Modification d'un élément
        fruits.set(1, "Fraise");

        // Suppression d'un élément
        fruits.remove(2);

        // Parcours de la liste
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
    }
}
Ajout des 3 élements Pomme Banane Orange

Modification de l'élément 1 en Fraise
Supression de l'élement 2

Dans cet exemple, nous avons créé une ArrayList appelée fruits pour stocker des chaînes de caractères. Nous avons ajouté trois éléments à la liste en utilisant la méthode add(). Nous avons ensuite accédé au premier élément de la liste en utilisant la méthode get() et l’avons affiché. Nous avons également modifié le deuxième élément de la liste en utilisant la méthode set() et supprimé le troisième élément en utilisant la méthode remove(). Enfin, nous avons parcouru tous les éléments de la liste en utilisant une boucle for-each et les avons affichés.

Les ArrayList offrent plusieurs avantages par rapport aux tableaux, tels que la possibilité de changer de taille dynamiquement et l’utilisation de méthodes prédéfinies pour effectuer des opérations courantes telles que l’ajout, la suppression et la modification d’éléments. Cependant, ils ont également des inconvénients, tels que des performances légèrement inférieures pour certaines opérations en raison de leur nature dynamique.

En résumé, les ArrayList en Java sont des structures de données dynamiques qui peuvent être utilisées pour stocker un nombre variable d’éléments. Ils offrent plusieurs avantages par rapport aux tableaux, mais ont également des inconvénients à prendre en compte lors du choix de la structure de données appropriée pour votre programme.

 

Exemple 1

 créer un tableau en Java pour stocker les informations sur différentes espèces de baleines :

 
public class Baleine {
    private String nom;
    private double taille;
    private double poids;
    private int nombre;

    public Baleine(String nom, double taille, double poids, int nombre) {
        this.nom = nom;
        this.taille = taille;
        this.poids = poids;
        this.nombre = nombre;
    }

    @Override
    public String toString() {
        return "Nom: " + nom + ", Taille: " + taille + " mètres, Poids: " + poids + " tonnes, Nombre: " + nombre;
    }
}

public class Main {
    public static void main(String[] args) {
        // Création d'un ArrayList pour stocker les informations sur différentes espèces de baleines
        ArrayList<Baleine> baleines = new ArrayList<>();

        // Ajout des informations sur les baleines à l'ArrayList
        baleines.add(new Baleine("Baleine bleue", 30, 100, 15000)); // Les chiffres sont des estimations
        baleines.add(new Baleine("Rorqual commun", 20, 50, 100000)); // Les chiffres sont des estimations
        baleines.add(new Baleine("Cachalot", 18, 45, 550000)); // Les chiffres sont des estimations
        baleines.add(new Baleine("Baleine boréale", 18, 75, 10000)); // Les chiffres sont des estimations
        baleines.add(new Baleine("Baleine à bosse", 16, 40, 80000)); // Les chiffres sont des estimations
        
        // Ajout d'autres espèces de baleines à l'ArrayList
        baleines.add(new Baleine("Béluga", 5.5, 1.5, 150000)); // Les chiffres sont des estimations
        baleines.add(new Baleine("Baleine de Minke", 10, 10, 800000)); // Les chiffres sont des estimations
        baleines.add(new Baleine("Bérardie d'Arnoux", 12.5, 14, 50000)); // Les chiffres sont des estimations

        // Affichage des informations sur les baleines
        for (Baleine baleine : baleines) {
            System.out.println(baleine);
        }
    }
}

Dans cet exemple, nous ajoutons plus d’espèces de baleines à l’ArrayList baleines. Chaque objet Baleine représente une espèce de baleine et contient des informations sur le nom de l’espèce, la taille moyenne de l’espèce (en mètres), le poids moyen de l’espèce (en tonnes) et le nombre approximatif d’individus de l’espèce dans le monde. Enfin, nous utilisons une boucle for-each pour afficher les informations sur chaque espèce de baleine.

Un Arraylist peut contenir d'autres ArrayList

Voici un exemple de code qui crée un ArrayList<ArrayList<String>> pour stocker les informations sur différentes espèces préhistoriques liées à l’évolution des baleines en Java:

 
import java.util.ArrayList;

public class ExempleBaleinesPrehistoriques {
    public static void main(String[] args) {
        // Création d'un ArrayList pour stocker les informations sur une espèce
        ArrayList<String> pakicetus = new ArrayList<String>();
        pakicetus.add("Pakicetus");
        pakicetus.add("Pakicetus inachus");
        pakicetus.add("2");

        ArrayList<String> ambulocetus = new ArrayList<String>();
        ambulocetus.add("Ambulocetus");
        ambulocetus.add("Ambulocetus natans");
        ambulocetus.add("3");

        ArrayList<String> basilosaurus = new ArrayList<String>();
        basilosaurus.add("Basilosaurus");
        basilosaurus.add("Basilosaurus cetoides");
        basilosaurus.add("18");

        // Création d'un ArrayList pour stocker les informations sur les espèces préhistoriques
        ArrayList<ArrayList<String>> infosEspeces = new ArrayList<ArrayList<String>>();
        infosEspeces.add(pakicetus);
        infosEspeces.add(ambulocetus);
        infosEspeces.add(basilosaurus);

        // Affichage des informations sur les espèces préhistoriques
        for (ArrayList<String> info : infosEspeces) {
            System.out.println("Nom: " + info.get(0));
            System.out.println("Nom latin: " + info.get(1));
            System.out.println("Taille (en mètres): " + info.get(2));
            System.out.println();
        }
    }
}

Dans cet exemple, nous avons créé trois ArrayList pour stocker les informations sur différentes espèces préhistoriques liées à l’évolution des baleines. Chaque ArrayList contient le nom de l’espèce, le nom latin et la taille de l’espèce. Ensuite, nous avons créé un autre ArrayList appelé infosEspeces pour stocker ces ArrayList. Enfin, nous avons parcouru tous les éléments de la liste infosEspeces en utilisant une boucle for-each et affiché les informations sur chaque espèce.

Les références 0 1 2 de la liste infosEspeces contiennent des objets qui intégrènt les données.

 

1. Pakicetus:

Attribute Value
Nom Pakicetus
NomLatin Pakicetus inachus
Taille 2

2. Ambulocetus:

Attribute Value
Nom Ambulocetus
NomLatin Ambulocetus natans
Taille 3

3. Basilosaurus:

Attribute Value
Nom Basilosaurus
NomLatin Basilosaurus cetoides
Taille 18

 

Collection

 

a classe java.util.Collection est une interface en Java qui définit un ensemble de méthodes communes pour toutes les classes de collection, telles que les listes, les ensembles et les queues. Voici une liste des principales méthodes définies dans l'interface Collection :

  1. int size(): Cette méthode retourne le nombre d'éléments présents dans la collection.

  2. boolean isEmpty(): Elle vérifie si la collection est vide et renvoie true si c'est le cas, sinon false.

  3. boolean contains(Object o): Cette méthode détermine si la collection contient un élément spécifique. Elle renvoie true si l'élément est présent, sinon false.

  4. boolean add(E e): Elle ajoute un élément à la collection et renvoie true si l'ajout a réussi. Dans certaines implémentations, l'ajout peut échouer si la collection est limitée en taille.

  5. boolean remove(Object o): Elle supprime la première occurrence de l'élément spécifié dans la collection. Si l'élément est trouvé et supprimé, elle renvoie true, sinon false.

  6. boolean addAll(Collection<? extends E> c): Cette méthode ajoute tous les éléments d'une autre collection c à la collection actuelle.

  7. void clear(): Elle supprime tous les éléments de la collection, la laissant vide.

  8. boolean removeAll(Collection<?> c): Elle supprime tous les éléments de la collection qui sont également présents dans la collection spécifiée c. Elle renvoie true si des éléments ont été supprimés.

  9. boolean retainAll(Collection<?> c): Elle supprime tous les éléments de la collection qui ne sont pas présents dans la collection spécifiée c. Elle renvoie true si la collection a été modifiée.

  10. boolean containsAll(Collection<?> c): Cette méthode vérifie si tous les éléments de la collection spécifiée c sont présents dans la collection actuelle.

  11. Object[] toArray(): Elle convertit la collection en un tableau d'objets. Lorsque vous utilisez cette méthode, le type de tableau retourné est un tableau d'objets génériques (Object[]).

  12. <T> T[] toArray(T[] a): Cette méthode convertit la collection en un tableau du type spécifié T[]. Elle est utile lorsque vous voulez obtenir un tableau typé.

  13. Iterator<E> iterator(): Elle retourne un itérateur sur la collection, qui permet de parcourir les éléments de la collection de manière séquentielle.

  14. default Stream<E> stream(): À partir de Java 8, cette méthode retourne un flux (Stream) des éléments de la collection, ce qui permet d'effectuer des opérations de traitement de données en utilisant des expressions lambda.

Ces méthodes fournissent des fonctionnalités de base pour travailler avec des collections en Java. Les classes concrètes qui implémentent l'interface Collection, telles que ArrayList, HashSet, et LinkedList, fournissent des implémentations spécifiques de ces méthodes en fonction des caractéristiques de la collection.

 

En programmation, une collection est un ensemble d'objets ou de valeurs regroupés sous une seule entité. Les collections permettent de stocker, d'organiser et de manipuler des données de manière efficace. Les types de collections les plus courants sont les tableaux, les listes, les ensembles et les dictionnaires (ou maps). Voici un aperçu de chacun d'entre eux :

  1. Tableaux (Arrays) :

    • Un tableau est une structure de données linéaire qui contient une séquence d'éléments de même type.
    • Les éléments d'un tableau sont accessibles par leur indice, qui commence généralement à zéro pour le premier élément.
    • Les tableaux ont une taille fixe, ce qui signifie que le nombre d'éléments qu'ils contiennent ne change pas une fois qu'ils sont créés.

  2. Listes (Lists) :

    • Les listes sont similaires aux tableaux, mais elles peuvent changer de taille dynamiquement. Vous pouvez ajouter ou supprimer des éléments de la liste à tout moment.
    • Les listes sont très flexibles et sont souvent utilisées lorsque vous avez besoin de gérer des collections de données de taille variable.

  3. Ensembles (Sets) :

    • Un ensemble est une collection non ordonnée d'éléments uniques. Cela signifie qu'il ne peut pas y avoir de doublons dans un ensemble.
    • Les ensembles sont utiles lorsque vous devez effectuer des opérations de comparaison (intersection, union, différence) entre des collections de données.

  4. Dictionnaires (Maps ou Hash Tables) :

    • Un dictionnaire est une collection de paires clé-valeur, où chaque clé est associée à une valeur.
    • Les dictionnaires permettent de rechercher rapidement des valeurs en fonction de leur clé, ce qui en fait une structure de données très efficace pour de nombreuses applications.

Chaque langage de programmation peut avoir sa propre implémentation de ces collections, avec des fonctionnalités et des méthodes spécifiques. Par exemple, en Python, vous avez des listes (list), des ensembles (set) et des dictionnaires (dict). En Java, vous avez des tableaux (array), des ArrayLists, des HashSet et des HashMaps, parmi d'autres.

Les collections sont essentielles en programmation car elles vous permettent de gérer des données de manière organisée et efficace. Le choix de la collection dépend souvent des besoins spécifiques de votre programme, tels que la rapidité d'accès, la capacité à gérer des doublons, ou la flexibilité en termes de taille.

 

Exercice

Ajoutez une méthode qui cacule le poids au mètre pour une baleine donnée de l'Exemple 1

Ajoutez une méthode qui affiche les cétacés par ordres du poids total estimé pour chaque espèce.

Faire un boucle qui affiche le poid au mètre de toutes les baleines

Modifié le: mardi 30 avril 2024, 05:55