En Java, un tableau est une structure de données linéaire importante qui nous permet de stocker plusieurs valeurs du même type.

• Les tableaux en Java sont des objets comme tous les autres objets des tableaux Java héritent implicitement de la classe java.lang.Object. Cela vous permet d'invoquer des méthodes définies dans Object (telles que toString() equals() et hashCode()).
• Les tableaux ont une propriété de longueur intégrée qui fournit le nombre d'éléments dans le tableau

public class Geeks {  public static void main(String[] args)  {  // initializing array  int[] arr = {40 55 63 17 22};  // size of array  int n = arr.length;  // traversing array  for (int i = 0; i < n; i++)  System.out.print(arr[i] + ' ');  } } 

40 55 63 17 22 

Principales fonctionnalités des tableaux

• Stocker les primitives et les objets : Les tableaux Java peuvent contenir à la fois des types primitifs (comme int char boolean, etc.) et des objets (comme String Integer, etc.)
• Allocation de mémoire contiguë Lorsque nous utilisons des tableaux de types primitifs, les éléments sont stockés dans des emplacements contigus. Pour les types non primitifs, les références des éléments sont stockées à des emplacements contigus.
• Indexation base zéro : Le premier élément du tableau est à l'index 0.
• Longueur fixe : Après avoir créé un tableau, sa taille est fixe ; nous ne pouvons pas le changer.

Fonctionnement de base sur les tableaux en Java

1. Déclarer un tableau

La forme générale de déclaration de tableau est 

// Méthode 1 :
int arr[];

// Méthode 2 :
int[] arr;

Le type d'élément détermine le type de données de chaque élément qui comprend le tableau. Comme un tableau d'entiers, nous pouvons également créer un tableau d'autres types de données primitifs comme char float double etc. ou des types de données définis par l'utilisateur (objets d'une classe).

Note: C'est simplement ainsi que nous pouvons créer une variable de tableau, aucun tableau réel n'existe. Il indique simplement au compilateur que cette variable (int Array) contiendra un tableau de type entier.

2. Initialisation d'un tableau en Java

Lorsqu'un tableau est déclaré, seule une référence à un tableau est créée. Nous utilisons new pour allouer un tableau de taille donnée.

'abc' est en chiffres'

int arr[] = nouveau int[taille];

• La déclaration de tableau est généralement statique, mais si la taille n'est pas définie, le tableau est dimensionné dynamiquement.
• La mémoire des tableaux est toujours allouée dynamiquement (sur le segment de tas) en Java. Ceci est différent du C/C++ où la mémoire peut être allouée statiquement ou dynamiquement.
• Les éléments du tableau alloués par new seront automatiquement initialisés à zéro (pour les types numériques), false (pour les booléens) ou null (pour les types référence).

Tableau littéral en Java

Dans une situation où la taille du tableau et les variables du tableau sont déjà connues, des littéraux de tableau peuvent être utilisés. 

// Déclaration d'un tableau littéral
int[] arr = nouveau int[]{ 12345678910 };

• La longueur de ce tableau détermine la longueur du tableau créé.
• Il n'est pas nécessaire d'écrire la nouvelle partie int[] dans les dernières versions de Java.

3. Modifier un élément du tableau

Pour modifier un élément, attribuez une nouvelle valeur à un index spécifique. L'index commence par 0 et se termine à (taille totale du tableau) -1.

objet en programmation Java

// Changement du premier élément en 90
arr[0] = 90 ;

4. Longueur du tableau

Nous pouvons obtenir la longueur d'un tableau en utilisant la propriété length :

// Obtention de la longueur du tableau
int n = arr.longueur ;

5. Accès et mise à jour de tous les éléments du tableau

• Tous les éléments du tableau sont accessibles à l’aide de Java for Loop.
• Chaque élément du tableau est accessible via son index.

Un programme Java pour illustrer la création d'un tableau d'entiers place certaines valeurs dans le tableau et imprime chaque valeur sur la sortie standard

class Geeks {  public static void main(String[] args)  {  // declares an Array of integers.  int[] arr;  // allocating memory for 5 integers.  arr = new int[5];  // initialize the elements of the array  // first to last(fifth) element  arr[0] = 2;  arr[1] = 4;  arr[2] = 8;  arr[3] = 12;  arr[4] = 16;  // accessing the elements of the specified array  for (int i = 0; i < arr.length; i++)  System.out.println('Element at index ' +  i + ' : ' + arr[i]);  } } 

Element at index 0 : 2 Element at index 1 : 4 Element at index 2 : 8 Element at index 3 : 12 Element at index 4 : 16 

Tableaux d'objets en Java

Un tableau d'objets est créé comme un tableau d'éléments de données de type primitif

Exemple : Ici, nous prenons une classe d'étudiant et créons un tableau de Student avec cinq objets Student stockés dans le tableau. Les objets Student doivent être instanciés à l'aide du constructeur de la classe Student et leurs références doivent être affectées aux éléments du tableau.

class Student {  public int roll_no;  public String name;    Student(int roll_no String name){  this.roll_no = roll_no;  this.name = name;  } } public class Geeks {  public static void main(String[] args){    // declares an Array of Student  Student[] arr;  // allocating memory for 5 objects of type Student.  arr = new Student[5];  // initialize the elements of the array  arr[0] = new Student(1 'aman');  arr[1] = new Student(2 'vaibhav');  arr[2] = new Student(3 'shikar');  arr[3] = new Student(4 'dharmesh');  arr[4] = new Student(5 'mohit');  // accessing the elements of the specified array  for (int i = 0; i < arr.length; i++)  System.out.println('Element at ' + i + ' : { '  + arr[i].roll_no + ' '  + arr[i].name+' }');  } } 

Element at 0 : { 1 aman } Element at 1 : { 2 vaibhav } Element at 2 : { 3 shikar } Element at 3 : { 4 dharmesh } Element at 4 : { 5 mohit } 

Que se passe-t-il si nous essayons d'accéder à des éléments en dehors de la taille du tableau ?

JVM lance ArrayIndexOutOfBoundsException pour indiquer que le tableau a été accédé avec un index illégal. L'index est soit négatif, soit supérieur ou égal à la taille d'un tableau.

Le code ci-dessous montre ce qui se passe si nous essayons d'accéder à des éléments en dehors de la taille du tableau :

public class Geeks {  public static void main(String[] args)  {  int[] arr = new int[4];  arr[0] = 10;  arr[1] = 20;  arr[2] = 30;  arr[3] = 40;  System.out.println(  'Trying to access element outside the size of array');  System.out.println(arr[5]);  } } 

Sortir:

Passer des tableaux aux méthodes

Comme les variables, nous pouvons également transmettre des tableaux aux méthodes. Par exemple, le programme ci-dessous transmet le tableau à la méthode sum pour calculer la somme des valeurs du tableau.

essayez d'attraper Java

Exemple:

public class Geeks {  // Driver method  public static void main(String args[])  {  int arr[] = { 3 1 2 5 4 };  // passing array to method m1  sum(arr);  }  public static void sum(int[] arr)  {  // getting sum of array values  int sum = 0;  for (int i = 0; i < arr.length; i++)  sum += arr[i];  System.out.println('sum of array values : ' + sum);  } } 

sum of array values : 15 

Explication

• Ce programme Java montre comment transmettre un tableau à une méthode.
• Un tableau d'entiers arr est déclaré et initialisé dans la méthode main.
• La méthode sum() est appelée avec arr comme argument.
• Dans la méthode sum(), tous les éléments du tableau sont ajoutés à l’aide d’une boucle for.
• La somme finale est ensuite imprimée sur la console.

Renvoi de tableaux à partir de méthodes

Comme d'habitude, une méthode peut également renvoyer un tableau. Par exemple, le programme ci-dessous renvoie un tableau de la méthode m1. 

Exemple:

class Geeks {  // Driver method  public static void main(String args[])  {  int arr[] = m1();  for (int i = 0; i < arr.length; i++)  System.out.print(arr[i] + ' ');  }  public static int[] m1()  {  // returning array  return new int[] { 1 2 3 };  } } 

1 2 3 

Avantages des tableaux Java

• Accès efficace : L'accès à un élément par son index est rapide et a une complexité temporelle constante O(1).
• Gestion de la mémoire : Les tableaux ont une taille fixe, ce qui rend la gestion de la mémoire simple et prévisible.
• Organisation des données : Les tableaux aident à organiser les données de manière structurée, ce qui facilite la gestion des éléments associés.

Inconvénients des tableaux Java

• Taille fixe : Une fois qu'un tableau est créé, sa taille ne peut pas être modifiée, ce qui peut entraîner un gaspillage de mémoire si la taille est surestimée ou un stockage insuffisant si elle est sous-estimée.
• Homogénéité des types : Les tableaux ne peuvent stocker que des éléments du même type de données, ce qui peut nécessiter un traitement supplémentaire pour des types de données mixtes.
• Insertion et suppression : L'insertion ou la suppression d'éléments, en particulier au milieu d'un tableau, peut être coûteuse car elle peut nécessiter le déplacement d'éléments.

Articles connexes

• Tableau dentelé en Java
• Boucle For-each en Java
• Classe de tableaux en Java