Java の配列の概要

La programmation implique souvent la gestion et la manipulation de grands ensembles de données, pour lesquelles des structures de données efficaces et efficientes sont cruciales. Les tableaux constituent une structure de données fondamentale en informatique et permettent de stocker une séquence d'éléments de taille fixe du même type. Dans ce blog, nous ferons un voyage approfondi à travers les tableaux en Java : comprendre ce qu'ils sont, leur syntaxe, comment les utiliser et leur gestion de la mémoire.

Pourquoi avons-nous besoin de tableaux ?

Lorsque vous travaillez avec des variables en Java, vous pouvez déclarer et initialiser chacune d'elles individuellement, comme :

java
int a = 19;
String name = "John Doe";

Cependant, cette approche devient inefficace si vous devez gérer plusieurs valeurs du même type. Par exemple, si vous deviez stocker plusieurs numéros ou noms de rôle, coder en dur chaque valeur n'est pas pratique. Les tableaux sont utiles car ils vous permettent de stocker efficacement une collection de valeurs. Par exemple, si vous devez stocker cinq numéros de rôle, vous pouvez utiliser des tableaux.

Que sont les tableaux ?

Un tableau est essentiellement une collection d'éléments de données du même type. Les tableaux peuvent stocker des types de données primitifs tels que des entiers, des flottants et des caractères, ainsi que des objets. Par exemple :

int[] rollNumbers = new int[5];
String[] names = {"Alice", "Bob", "Charlie"};

Syntaxe des tableaux

La syntaxe pour déclarer un tableau en Java est simple :

dataType[] arrayName = new dataType[size];

Par exemple, pour créer un tableau de cinq entiers :

int[] rollNumbers = new int[5];

Alternativement, vous pouvez déclarer et initialiser un tableau sur une seule ligne :

int[] rollNumbers = {23, 55, 9, 18, 45};

Caractéristiques des tableaux

Éléments homogènes

Dans un tableau, tous les éléments doivent être du même type. Vous ne pouvez pas mélanger les types dans un seul tableau ; par exemple :

int[] nums = {1, 2, "three"}; // Will cause a compile-time error

Taille fixe

Une fois un tableau créé, sa taille est fixe. Vous ne pouvez pas agrandir ou réduire sa taille. Cette contrainte peut souvent conduire à la sélection d'autres structures de données, comme ArrayList, pour des besoins de données plus dynamiques.

Gestion de la mémoire interne

Les tableaux en Java se composent de :

• Stack Memory : Stocke la variable de référence du tableau.
• Heap Memory : Stocke l'objet tableau réel et ses éléments.

Lorsque vous déclarez un tableau, la référence est créée dans la mémoire de pile et l'objet tableau est stocké dans la mémoire du tas.

Allocation de mémoire

Il y a deux étapes critiques dans l'allocation de mémoire d'une baie :

1. Déclaration : La variable de référence est créée, mais elle ne pointe nulle part.
2. Initialisation : La variable de référence pointe vers l'objet tableau réel dans le tas, qui contient les éléments.

Par exemple :

int[] rollNumbers; // Declaration
rollNumbers = new int[5]; // Initialization

Allocation de mémoire dynamique

Java effectue une allocation dynamique de la mémoire, ce qui signifie qu'au moment de l'exécution, il alloue la mémoire selon les besoins, ce qui le rend efficace dans la gestion de la mémoire.

Entrée et sortie dans des tableaux

Prise en compte

Pour remplir un tableau avec une entrée utilisateur, vous pouvez utiliser une boucle avec un scanner pour lire les entrées de la console.

Scanner scanner = new Scanner(System.in);
int[] arr = new int[5];
for (int i = 0; i < arr.length; i++) {
    System.out.print("Enter element " + (i + 1) + ": ");
    arr[i] = scanner.nextInt();
}

Impression de tableaux

Vous pouvez imprimer des tableaux à l'aide de boucles ou de la méthode utilitaire Arrays.toString() pour une sortie plus lisible.

for (int i = 0; i < arr.length; i++) {
    System.out.print(arr[i] + " ");
}

ou

System.out.println(Arrays.toString(arr));

Tableaux multidimensionnels

Les tableaux bidimensionnels, ou matrices, sont des tableaux de tableaux. La syntaxe d'un tableau 2D ressemble à ceci :

int[][] matrix = new int[3][3];

Exemple

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

Pour une saisie dynamique d'éléments dans un tableau 2D, des boucles imbriquées sont utilisées.

ArrayList : une alternative dynamique

Les tableaux en Java sont de taille fixe, ce qui entraîne des inefficacités lorsque le nombre d'éléments est inconnu au moment de la compilation. Cette limitation peut être surmontée en utilisant la classe ArrayList, qui fait partie du Java Collections Framework.

Utiliser ArrayList

La classe ArrayList permet un redimensionnement dynamique. Voici la syntaxe pour créer une ArrayList :

ArrayList<Integer> numbers = new ArrayList<>();

Vous pouvez ajouter et manipuler des éléments de manière dynamique :

numbers.add(1);
numbers.add(2);
numbers.add(3);
System.out.println(numbers); // Output: [1, 2, 3]

numbers.set(1, 10); // Change element at index 1
System.out.println(numbers); // Output: [1, 10, 3]

numbers.remove(0); // Remove element at index 0
System.out.println(numbers); // Output: [10, 3]

boolean contains = numbers.contains(10); // Check if the list contains 10
System.out.println(contains); // Output: true

Fonctionnement interne de ArrayList

En interne, ArrayList utilise des tableaux dynamiques avec une capacité initiale fixe. Lorsque cette capacité est épuisée, un nouveau tableau avec une plus grande capacité est créé et les éléments existants sont copiés. Ce processus garantit que l'ArrayList peut croître dynamiquement à mesure que des éléments sont ajoutés.

Opérations communes sur les tableaux

Trouver le maximum d'éléments

Pour trouver l'élément maximum dans un tableau, parcourez le tableau et gardez une trace de la valeur la plus élevée :

int max = arr[0];
for (int i = 1; i < arr.length; i++) {
    if (arr[i] > max) {
        max = arr[i];
    }
}
System.out.println("Maximum value: " + max);

Inverser un tableau

Pour inverser un tableau, utilisez une technique à deux pointeurs :

public static void reverse(int[] arr) {
    int start = 0;
    int end = arr.length - 1;
    while (start < end) {
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
        start++;
        end--;
    }
}

Calling the reverse function:

int[] arr = {1, 2, 3, 4, 5};
reverse(arr);
System.out.println(Arrays.toString(arr)); // Output: [5, 4, 3, 2, 1]

Conclusion

Arrays are a critical data structure in Java, enabling the storage and manipulation of data sets efficiently. While fixed in size, arrays are powerful and versatile when dealing with homogeneous data types. For dynamic data needs, ArrayList provides additional flexibility, allowing arbitrary growth in size. Understanding these structures and their operations lays the groundwork for more advanced programming and data management. Moreover, practicing array operations and understanding their underlying memory management helps in writing more efficient and optimized code.

以上がJava の配列の概要の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。