Qu'est-ce qu'un Tableau ?

Tableaux

Stocker des informations exclusivement dans des variables n'est pas toujours pratique, car cela consommerait une quantité significative de mémoire de pile et nécessiterait un nombre substantiel de lignes de code.

La solution à ce problème est les tableaux.

Explorons la syntaxe de base pour déclarer un tableau en Java :

Main


              1
            
dataType[] arrayName = new dataType[capacity];

Nous pouvons utiliser n'importe quel type de données lors de la déclaration d'un tableau, y compris int, float, char, et plus encore. Vous pouvez même utiliser vos classes personnalisées dans les déclarations de tableau. Apprendre à créer vos propres classes et leurs objets sera couvert dans un cours séparé Java Avancé.

Il est obligatoire de spécifier la taille du tableau entre crochets ([]). Considérons un exemple de création d'un tableau de type int avec une taille de 5 :

Main


              12345678910
            
package com.example;

public class Main {
    public static void main(String[] args) {
        // Declares a new int array with a length of 5
        int[] intArray = new int[5];
        // Prints the size of the array
        System.out.println(intArray.length);
    }
}

Comme vous l'avez peut-être remarqué, nous avons utilisé quelque chose d'inconnu en conjonction avec la sortie de la console. Cette chose est appelée une propriété du tableau.

Les tableaux ont leurs propres propriétés. Les propriétés sont appelées en utilisant la notation par point (.) sur l'objet avec elles. Dans notre exemple, le tableau intArray a des propriétés, et nous en utilisons une. La propriété .length renvoie la taille (longueur) du tableau en tant que valeur int. Cela peut également être écrit différemment :

Main


              123456789101112
            
package com.example;

public class Main {
    public static void main(String[] args) {
        // Declares a new int array with a length of 5
        int[] intArray = new int[5];
        // Declares a new int with the value of the array's size
        int length = intArray.length;
        // Prints the size of the array
        System.out.println(length);
    }
}

Maintenant, examinons trois méthodes et propriétés fondamentales pour travailler avec les tableaux :

Arrays.sort(array): trie les éléments du tableau par ordre croissant ;
Arrays.fill(array, value): définit tous les éléments du tableau à la valeur spécifiée ;
Arrays.toString(array): convertit le tableau en une représentation sous forme de chaîne, facilitant l'affichage de ses éléments.

Main


              1234567891011121314151617
            
package com.example;

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] array = {5, 2, 9, 1, 6};
        
        // Sort the array
        Arrays.sort(array);
        System.out.println("Sorted array: " + Arrays.toString(array));
        
        // Fill the array with the value 0
        Arrays.fill(array, 0);
        System.out.println("Array after filling: " + Arrays.toString(array));
    }
}

Tout d'abord, il trie le tableau par ordre croissant en utilisant Arrays.sort() et affiche le tableau trié en utilisant Arrays.toString(), qui convertit le tableau en un format de chaîne lisible. Ensuite, tous les éléments du tableau sont remplacés par 0 en utilisant Arrays.fill(), et le tableau mis à jour est imprimé dans le même format lisible.

Comment accéder à des données spécifiques dans un tableau ?

Les tableaux en Java sont indexés. Chaque élément du tableau est situé dans sa cellule et se voit attribuer un ID unique. La numérotation des éléments dans le tableau commence à 0. Supposons que nous ayons un tableau de nombres de zéro à neuf, il contient donc 10 éléments.

Examinons un diagramme qui illustre comment les éléments sont organisés dans le tableau :

Si nous avons un tableau avec 10 éléments, le premier élément sera stocké à l'index 0, et le dernier à l'index 9, car l'indexation commence à zéro.

La pratique est toujours meilleure que la simple théorie, alors explorons un exemple d'ajout et de suppression d'éléments d'un tableau en utilisant des index :

Main


              12345678910111213141516
            
package com.example;

public class Main {
    public static void main(String[] args) {
        // Declares a new int array with a length of 5
        int[] intArray = new int[5];
        // Fills the array with numbers from 1 to 5
        intArray[0] = 1;
        intArray[1] = 2;
        intArray[2] = 3;
        intArray[3] = 4;
        intArray[4] = 5;
        // Prints the fourth element of the array
        System.out.println(intArray[3]);
    }
}

Nous avons rempli notre tableau avec des éléments de un à cinq en spécifiant chaque élément avec un indice. Cependant, cette approche manque d'élégance et nécessite de nombreuses lignes de code. Explorons une méthode alternative de déclaration d'un tableau qui vient pré-rempli :

Main


              12345678910
            
package com.example;

public class Main {
    public static void main(String[] args) {
        // Declares a new pre-filled int array with a length of 5
        int[] intArray = {1, 2, 3, 4, 5};
        // Prints the first element of the array
        System.out.println(intArray[0]);
    }
}

Nous avons créé un tableau identique à celui que nous avons fait précédemment, mais cette fois, il a nécessité moins de lignes de code et semblait plus élégant.

Il est important de noter que lors de l'utilisation de cette notation de tableau, les éléments doivent être entourés d'accolades ({}) et séparés par des virgules.

1. Que sera-t-il imprimé lorsque nous exécuterons ce code ?

2. Que sera-t-il imprimé lorsque nous exécuterons ce code ?

Tout était clair ?

Merci pour vos commentaires !

Section 4. Chapitre 1