Outil Java Array (avec exemples)
En Java, l'objet tableau est utilisé pour stocker plusieurs informations. Cet utilitaire affecte séquentiellement certaines régions de mémoire en fonction de la taille de la matrice. En Java, un objet tableau peut contenir n'importe quelle forme de données primitives ou non primitives. Autrement dit, il peut contenir une liste d'entiers, de chaînes, d'objets, etc. Par conséquent, toutes les valeurs d'un tableau peuvent être des données d'un type de données spécifique. Dans certains langages de programmation, la valeur d'index d'un tableau commence à 0. En Java, vous pouvez déclarer des tableaux unidimensionnels et multidimensionnels. En utilisant un tableau, vous pouvez facilement organiser et trier une liste de données.
Le plus gros inconvénient des tableaux est qu'ils sont fixes et ne peuvent pas être modifiés au moment de l'exécution. Cet article vous montrera comment déclarer, initialiser, accéder et modifier des objets tableau.
Avantages
Optimisation du code :il optimise le code pour obtenir et trier les données rapidement. En conséquence, nous pouvons obtenir toutes les données placées à un emplacement d'index en utilisant un accès aléatoire.
Inconvénients
Limite de taille :dans le tableau, nous ne pouvons stocker que des éléments de taille fixe. Il ne se dilate pas lors de l'utilisation. En Java, un framework de collecte est utilisé pour gérer ce problème, qui se développe automatiquement.
Types de tableaux en Java
Les tableaux peuvent être divisés en deux types.
- Tableau unidimensionnel
- Tableau multidimensionnel
Tableau unidimensionnel :syntaxe
datatype array_name[]; or datatype[] array_name;
Tout type de données spécifique est spécifié au moment de la déclaration du tableau, et le tableau stockera les données dans ce format.
Tableau à deux dimensions :syntaxe
datatype array_name[][]; or datatype[][] array_name;
Un tableau à deux dimensions, comme un tableau à une dimension, nécessite que le type de données soit spécifié et deux paires de troisièmes crochets pour définir la déclaration. Les données sont stockées dans un style tabulaire avec un nombre défini de lignes et de colonnes dans ce type de tableau.
Tableau unidimensionnel :déclaration, initialisation et accès
En Java, l'exemple suivant explique comment utiliser plusieurs tableaux unidimensionnels. Tout d'abord, un objet tableau numérique à deux éléments est déclaré et initialisé avec deux valeurs entières. Ensuite, un objet tableau de caractères à trois éléments est déclaré, avec deux caractères alloués aux premier et troisième index. Après cela, un tableau de chaînes à quatre éléments est déclaré et trois valeurs sont allouées en série aux trois index. L'index est utilisé pour imprimer les valeurs des tableaux d'entiers et de caractères, et la boucle "for" est utilisée pour imprimer les valeurs des tableaux de chaînes.
// arrayOneDimensional.java
public class arrayOneDimensional {
public static void main(String[] args) {
//first declare an array of numeric values
int number_array[] = new int[2];
//value assignment to array
number_array[0] = 24;
number_array[1] = 36;
//Declare a character array
char character_array[] = new char[3];
//Assign values
character_array[0] = 'X';
character_array[1] = 'W';
character_array[2] = 'Z';
//String array declaration
String[] string_array = new String[6];
//Assign values
string_array[0] = "Lenovo";
string_array[1] = "HP";
string_array[2] = "Microsoft";
System.out.print("\nNumeric array values : "+number_array[0]+" "+number_array[1]+"\n");
System.out.print("Character array values : "+character_array[0]+" "+character_array[2]+"\n");
System.out.print("The values of string array are : ");
//Iterate the array using a for loop
for (int j = 0; j < string_array.length; j++){
System.out.print(string_array[j]+" ");
}
}
} La sortie du code est visible dans l'image ci-dessous. Les valeurs des deux premiers tableaux sont imprimées en fonction de la valeur d'index attribuée. La valeur nulle est attribuée par défaut sur le dernier index du tableau de chaînes imprimé, et le dernier index du troisième tableau n'est pas attribué.
Créer un tableau de valeurs et trier le tableau
Dans l'exemple précédent, l'index est utilisé pour initialiser les valeurs du tableau indépendamment. Cet exemple montre comment les valeurs de tableau peuvent être initialisées lorsque le tableau est déclaré. Dans ce cas, le code déclare un tableau numérique à huit éléments contenant des valeurs. La boucle "for" est ensuite utilisée pour sortir les valeurs. Le tableau Java offre une méthode sort() intégrée pour trier les valeurs du tableau. Cette fonction trie les valeurs du tableau avant de les imprimer en utilisant à nouveau la boucle "for".
// createValuesArrayAndSort.java
import java.util.Arrays;
public class array2 {
public static void main(String[] args) {
// numeric array initialization
int arr_vals[] = {72, 94, 25, 66, 80, 54, 41, 20};
System.out.print("Before sorting the Array \n");
//use a for loop to iterate through the array
for (int j = 0; j < arr_vals.length; j++)
System.out.print(arr_vals[j]+" ");
// use the sort() method to sort the array
Arrays.sort(arr_vals);
System.out.print("\n\nAfter sorting the Array \n");
for (int j = 0; j < arr_vals.length; i++)
System.out.print(arr_vals[j]+" ");
}
} La sortie du code est visible dans l'image ci-dessous. Le contenu du tableau est imprimé en premier, suivi des valeurs du tableau triées affichées dans l'ordre croissant.
Tableau à deux dimensions :déclaration, initialisation et accès
Cet exemple montre comment déclarer, initialiser et accéder à un tableau à deux dimensions à l'aide de Java. Pour spécifier les deux dimensions du tableau, vous devez utiliser deux crochets "[]". La première paire de troisièmes crochets définit les numéros de ligne, tandis que la deuxième paire de troisièmes crochets définit les numéros de colonne.
Deux méthodes pour déclarer un tableau à deux dimensions sont présentées dans le code. Tout d'abord, un tableau à deux dimensions nommé score avec deux lignes et deux colonnes est déclaré. Quatre valeurs numériques sont ensuite attribuées dans les quatre index, et deux sont imprimées. Ensuite, un tableau à deux dimensions nommé clients avec quatre lignes et trois colonnes est déclaré avec des valeurs.
Chaque valeur du tableau est lue à l'aide d'une boucle "for". La boucle lira quatre lignes du tableau et les valeurs de chaque colonne quatre fois, affichant le résultat préparé après chaque itération.
// twoDimensionalArray.java
public class twoDimensionalArray {
public static void main(String[] args) {
// two-dimensional numeric array declaration with length
int[][] score=new int[2][2];
//Initialize the array with values
score[0][0] = 991;
score[0][1] = 600;
score[1][0] = 992;
score[1][1] = 800;
// printing the array values
System.out.print("The score of " + score[1][0] + " is " + score[1][1]);
// two-dimensional string array declaration with values
String customer_info[][]={{"25453","Tom Clint","Chairman"},
{"25368","Sam Bright","Director"},
{"25443","Ann Faith","GM"},
{"25332","Joy Brown","MD"}};
// using for loop to iterate through the array values
for(int i=0; i<4; i++)
{
System.out.print("\nThe position of: " + customer_info[i][1]+"("+customer_info[i][0]+")" +
" is " + customer_info[i][2]);
}
}
} La sortie du code est visible dans l'image ci-dessous. La ligne du haut affiche la sortie du tableau des scores, tandis que les quatre lignes suivantes affichent le résultat du tableau des clients.
Jagged Array de Java
Un tableau irrégulier est créé lorsque le nombre de colonnes dans un tableau 2D est impair. Autrement dit, il s'agit d'un tableau de tableaux avec un nombre variable de colonnes.
//JaggedArrayInJava.java
// jagged array Java Program
class JaggedArrayInJava{
public static void main(String[] args){
//declaring a 2D array with odd columns
int jagged_arr[][] = new int[3][];
jagged_arr[0] = new int[3];
jagged_arr[1] = new int[4];
jagged_arr[2] = new int[2];
//initializing a jagged array
int count = 0;
for (int i=0; i<jagged_arr .length; i++)
for(int j=0; j<jagged_arr[i].length; j++)
arr[i][j] = count++;
//jagged array data printing
for (int i=0; i<arr.length; i++){
for (int j=0; j<jagged_arr[i].length; j++){
System.out.print(jagged_arr[i][j]+" ");
}
System.out.println();
}
}
} 
Cloner un tableau en Java
Nous pouvons créer un clone du tableau Java car il implémente l'interface Cloneable. Lorsque nous créons une copie complète d'un tableau unidimensionnel, nous créons une copie complète du tableau Java. Il copiera la valeur réelle. Si nous créons le clone d'un tableau multidimensionnel, il crée la copie superficielle du tableau Java, ce qui signifie qu'il copie les références.
// CloneArray.java
// clone the array Java Program
class CloneArray{
public static void main(String args[]){
int arr_vals[]={12,89,41,98};
System.out.println("The original array:");
for(int i:arr_vals)
System.out.println(i);
System.out.println("The array clone:");
int clone_arr[]=arr_vals .clone();
for(int i:clone_arr)
System.out.println(i);
System.out.println("Are they equal to each other?");
System.out.println(arr_vals==clone_arr);
}} 
Copie de tableaux en Java
La fonction arraycopy() de la classe System permet de copier un tableau dans un autre.
// ArrayCopyExample.java
//Java Program to copy a source array into a destination array in Java
class ArrayCopyExample {
public static void main(String[] args) {
// source array declaration
char[] sourceArray = { 'c', 'o', 'd', 'e', 'u', 'n', 'd', 'e', 'r', 's', 'c', 'o', 'r', 'e', 'd' };
// destination array declaration
char[] destinationArray = new char[9];
//copying array using System.arraycopy() method
System.arraycopy(sourceArray, 2, destinationArray, 0, 9);
//destination array printing
System.out.println(String.valueOf(destinationArray));
}
} 
Conclusion
Dans la plupart des cas, un tableau est une collection d'éléments de type similaire stockés dans une seule adresse mémoire. Un tableau en Java est un objet qui inclut des composants du même type de données. De plus, les éléments d'un tableau sont conservés dans une seule adresse mémoire. Il s'agit d'une structure de données dans laquelle nous enregistrons des éléments comparables. Dans un tableau Java, nous ne pouvons stocker qu'un nombre fixe d'éléments.
L'élément initial du tableau est situé au 0ème index du tableau, et le deuxième élément est stocké au 1er index, et ainsi de suite. Ce didacticiel illustre les utilisations de base des tableaux unidimensionnels et bidimensionnels en Java à l'aide d'exemples simples. Ce didacticiel apprendra aux programmeurs Java novices comment utiliser les tableaux et les utiliser correctement dans leur code.
