En Java, tableau est un groupe de variables de même type désignées par un nom commun. Les tableaux en Java fonctionnent différemment qu’en C/C++. Voici quelques points importants concernant les tableaux Java.

Tableaux en Java

• En Java, tous les tableaux sont alloués dynamiquement. (discuté ci-dessous)
• Les tableaux peuvent être stockés dans une mémoire contiguë [emplacements de mémoire consécutifs].
• Puisque les tableaux sont des objets en Java, nous pouvons trouver leur longueur en utilisant la propriété object longueur . Ceci est différent du C/C++, où nous trouvons la longueur en utilisant sizeof.
• Une variable de tableau Java peut également être déclarée comme d'autres variables avec [] après le type de données.
• Les variables du tableau sont ordonnées et chacune a un index commençant par 0.
• Le tableau Java peut également être utilisé comme champ statique, variable locale ou paramètre de méthode.

Un tableau peut contenir des primitives (int, char, etc.) et des références d'objet (ou non primitives) d'une classe selon la définition du tableau. Dans le cas de types de données primitifs, les valeurs réelles peuvent être stockées dans des emplacements mémoire contigus (JVM ne garantit pas ce comportement). Dans le cas des objets de classe, les objets réels sont stockés dans un segment de tas .

oups concept en java

Note: Ce stockage de tableaux nous aide à accéder de manière aléatoire aux éléments d'un tableau [Support Random Access].

Création, initialisation et accès à des tableaux

Tableaux unidimensionnels

La forme générale d'une déclaration de tableau unidimensionnel est

-- type var-name[]; -- type[] var-name;>

Une déclaration de tableau comporte deux composants : le type et le nom. taper déclare le type d'élément du tableau. 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). Ainsi, le type d’élément du tableau détermine le type de données que le tableau contiendra.

Exemple:

// both are valid declarations int intArray[]; int[] intArray; // similar to int we can declare // byte , short, boolean, long, float // double, char // an array of references to objects of // the class MyClass (a class created by user) MyClass myClassArray[]; // array of Object Object[] ao, // array of Collection // of unknown type Collection[] ca;>

Bien que la première déclaration établisse que int Array est une variable tableau, aucun tableau réel n'existe . Il indique simplement au compilateur que cette variable (int Array) contiendra un tableau de type entier. Pour lier un tableau int à un tableau physique réel d'entiers, vous devez en allouer un en utilisant nouveau et attribuez-le à int Array.

Instancier un tableau en Java

Lorsqu'un tableau est déclaré, seule une référence à un tableau est créée. Pour créer ou donner de la mémoire au tableau, vous créez un tableau comme ceci : La forme générale de nouveau tel qu'il s'applique aux tableaux unidimensionnels, se présente comme suit :

var-name = new type [size];>

Ici, taper précise le type de données allouées, taille détermine le nombre d'éléments dans le tableau, et nom-var est le nom de la variable de tableau liée au tableau. Utiliser nouveau pour allouer un tableau, vous devez préciser le type et le nombre d'éléments à allouer.

Exemple:

//declaring array int intArray[]; // allocating memory to array intArray = new int[20]; // combining both statements in one int[] intArray = new int[20];>

Note: Les éléments du tableau alloués par nouveau sera automatiquement initialisé à zéro (pour les types numériques), FAUX (pour booléen), ou nul (pour les types de référence). Référez-vous à valeurs de tableau par défaut en Java .

L'obtention d'un tableau est un processus en deux étapes. Tout d’abord, vous devez déclarer une variable du type de tableau souhaité. Deuxièmement, vous devez allouer de la mémoire pour contenir le tableau, en utilisant new, et l'attribuer à la variable du tableau. Ainsi, en Java , tous les tableaux sont alloués dynamiquement.

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.

// Declaring array literal int[] intArray = new int[]{ 1,2,3,4,5,6,7,8,9,10 };>

• 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.

Accès aux éléments du tableau Java à l'aide de la boucle for

Chaque élément du tableau est accessible via son index. L'index commence par 0 et se termine à (taille totale du tableau) -1. Tous les éléments du tableau sont accessibles à l’aide de Java for Loop.

 // accessing the elements of the specified array for (int i = 0; i>

Mise en œuvre:

// Java program to illustrate creating an array // of integers, puts some values in the array, // and prints each value to standard output. class GFG { public static void main(String[] args) { // declares an Array of integers. int[] arr; // allocating memory for 5 integers. arr = new int[5]; // initialize the first elements of the array arr[0] = 10; // initialize the second elements of the array arr[1] = 20; // so on... arr[2] = 30; arr[3] = 40; arr[4] = 50; // 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 : 10 Element at index 1 : 20 Element at index 2 : 30 Element at index 3 : 40 Element at index 4 : 50>

Complexité de la méthode ci-dessus :

Complexité temporelle : O(n)
Espace auxiliaire : O(1)

Vous pouvez également accéder aux tableaux Java en utilisant pour chaque boucle .

tutoriel sur le sélénium

Tableaux d'objets en Java

Un tableau d'objets est créé comme un tableau d'éléments de données de type primitif de la manière suivante.

Student[] arr = new Student[5]; //student is a user-defined class>

Syntaxe:

-- data type[] arrName; -- datatype arrName[]; -- datatype [] arrName;>

Exemple de tableaux d'objets

Exemple 1:

Vous trouverez ci-dessous la mise en œuvre du sujet mentionné ci-dessus :

import java.io.*; class GFG { public static void main (String[] args) { int [] arr=new int [4]; // 4 is the size of arr System.out.println('Array Size:'+arr.length); } }>

Array Size:4>

Le tableau étudiant contient cinq espaces mémoire, chacun de la taille d'une classe d'étudiant, dans lesquels l'adresse de cinq objets étudiants peut être stockée. 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 de la manière suivante.

Exemple 2 :

Vous trouverez ci-dessous la mise en œuvre du sujet mentionné ci-dessus :

// Java program to illustrate creating // an array of objects class Student { public int roll_no; public String name; Student(int roll_no, String name) { this.roll_no = roll_no; this.name = name; } } // Elements of the array are objects of a class Student. public class GFG { public static void main(String[] args) { // declares an Array of Students Student[] arr; // allocating memory for 5 objects of type Student. arr = new Student[5]; // initialize the first elements of the array arr[0] = new Student(1, 'aman'); // initialize the second elements of the array arr[1] = new Student(2, 'vaibhav'); // so on... 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>

Complexité de la méthode ci-dessus :

Complexité temporelle : O(n)
Espace auxiliaire : O(1)

Exemple 3

Un tableau d'objets est également créé comme :

// Java program to illustrate creating // an array of objects class Student { public String name; Student(String name) { this.name = name; } @Override public String toString(){ return name; } } // Elements of the array are objects of a class Student. public class GFG { public static void main (String[] args) { // declares an Array and initializing the elements of the array Student[] myStudents = new Student[]{new Student('Dharma'),new Student('sanvi'),new Student('Rupa'),new Student('Ajay')}; // accessing the elements of the specified array for(Student m:myStudents){ System.out.println(m); } } }>

Dharma sanvi Rupa Ajay>

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 :

// Code for showing error 'ArrayIndexOutOfBoundsException' public class GFG { 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

Trying to access element outside the size of array Exception in thread 'main' java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 4 at GFG.main(GFG.java:13)>

Exemple (itération du tableau) :

public class GFG { public static void main(String[] args) { int[] arr = new int[2]; arr[0] = 10; arr[1] = 20; for (int i = 0; i < arr.length; i++) System.out.println(arr[i]); } }>

10 20>

Complexité de la méthode ci-dessus :

Complexité temporelle : O(n), ici n est la taille du tableau.
Espace auxiliaire : O(1) , puisqu'aucun espace supplémentaire n'est requis.

Tableaux multidimensionnels en Java

Les tableaux multidimensionnels sont tableaux de tableaux avec chaque élément du tableau contenant la référence des autres tableaux. Ceux-ci sont également connus sous le nom Tableaux irréguliers . Un tableau multidimensionnel est créé en ajoutant un jeu de crochets ([]) par dimension.

Syntaxe du tableau multidimensionnel Java

Il existe 2 méthodes pour déclarer des tableaux multidimensionnels Java, comme mentionné ci-dessous :

-- datatype [][] arrayrefvariable; -- datatype arrayrefvariable[][];>

Exemple:

// Java Program to demonstrate // Java Multidimensional Array import java.io.*; // Driver class class GFG { public static void main(String[] args) { // Syntax int[][] arr = new int[3][3]; // 3 row and 3 column // Number of Rows System.out.println('Number of Rows:'+ arr.length); // Number of Columns System.out.println('Number of Columns:'+ arr[0].length); } }>

Number of Rows:3 Number of Columns:3>

Déclaration de tableau multidimensionnel

int[][] intArray = new int[10][20]; //a 2D array or matrix int[][][] intArray = new int[10][20][10]; //a 3D array>

Exemple de tableau multidimensionnel en Java

Exemple 1:

Vous trouverez ci-dessous la mise en œuvre de la méthode ci-dessus :

0,06 en fraction

// Java Program to Multidimensional Array // Driver Class public class multiDimensional { // main function public static void main(String args[]) { // declaring and initializing 2D array int arr[][] = { { 2, 7, 9 }, { 3, 6, 1 }, { 7, 4, 2 } }; // printing 2D array for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) System.out.print(arr[i][j] + ' '); System.out.println(); } } }>

2 7 9 3 6 1 7 4 2>

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 somme pour calculer la somme des valeurs du tableau.

// Java program to demonstrate // passing of array to method public class Test { // 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>

Complexité de la méthode ci-dessus :

Complexité temporelle : Sur)
Espace Auxiliaire : O(1)

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 .

// Java program to demonstrate // return of array from method class Test { // 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>

Complexité de la méthode ci-dessus :

Complexité temporelle : O(n)
Espace auxiliaire : O(1)

Objets de classe pour les tableaux

Chaque tableau est associé à un objet Class, partagé avec tous les autres tableaux ayant le même type de composant.

// Java program to demonstrate // Class Objects for Arrays class Test { public static void main(String args[]) { int intArray[] = new int[3]; byte byteArray[] = new byte[3]; short shortsArray[] = new short[3]; // array of Strings String[] strArray = new String[3]; System.out.println(intArray.getClass()); System.out.println( intArray.getClass().getSuperclass()); System.out.println(byteArray.getClass()); System.out.println(shortsArray.getClass()); System.out.println(strArray.getClass()); } }>

class [I class java.lang.Object class [B class [S class [Ljava.lang.String;>

Explication de la méthode ci-dessus :

1. La chaîne [I est la signature de type d'exécution pour le tableau d'objets de classe avec le type de composant int .
2. La seule superclasse directe d'un type tableau est java.lang.Object .
3. La chaîne [B est la signature de type d'exécution pour le tableau d'objets de classe avec le type de composant octet .
4. La chaîne [S est la signature de type d'exécution pour le tableau d'objets de classe avec le type de composant court .
5. La chaîne [L est la signature de type d'exécution pour le tableau d'objets de classe avec le type de composant d'une classe. Le nom de la classe est ensuite suivi.

Membres du tableau Java

Maintenant, comme vous le savez, les tableaux sont des objets d'une classe et une superclasse directe de tableaux est un objet de classe. Les membres d'un type de tableau sont tous les suivants :

• Le champ final public longueur contient le nombre de composants du tableau. La longueur peut être positive ou nulle.
• Tous les membres sont hérités de la classe Object ; la seule méthode d'Object qui n'est pas héritée est sa cloner méthode.
• La méthode publique cloner() remplace la méthode clone dans la classe Object et ne renvoie aucun exceptions vérifiées .

Types de tableaux et types d'éléments autorisés

Clonage d'un tableau unidimensionnel en Java

Lorsque vous clonez un tableau unidimensionnel, tel que Object[], une copie complète est effectuée avec le nouveau tableau contenant des copies des éléments du tableau d'origine par opposition aux références.

contient dans la chaîne

Vous trouverez ci-dessous la mise en œuvre de la méthode ci-dessus :

// Java program to demonstrate // cloning of one-dimensional arrays class Test { public static void main(String args[]) { int intArray[] = { 1, 2, 3 }; int cloneArray[] = intArray.clone(); // will print false as deep copy is created // for one-dimensional array System.out.println(intArray == cloneArray); for (int i = 0; i < cloneArray.length; i++) { System.out.print(cloneArray[i] + ' '); } } }>

false 1 2 3>

Clonage d'un tableau multidimensionnel en Java

Un clone d'un tableau multidimensionnel (comme Object[][]) est cependant une copie superficielle, c'est-à-dire qu'il ne crée qu'un seul nouveau tableau avec chaque tableau d'éléments une référence à un tableau d'éléments d'origine, mais les sous-tableaux sont partagé.

// Java program to demonstrate // cloning of multi-dimensional arrays class Test { public static void main(String args[]) { int intArray[][] = { { 1, 2, 3 }, { 4, 5 } }; int cloneArray[][] = intArray.clone(); // will print false System.out.println(intArray == cloneArray); // will print true as shallow copy is created // i.e. sub-arrays are shared System.out.println(intArray[0] == cloneArray[0]); System.out.println(intArray[1] == cloneArray[1]); } }>

false true true>

Foire aux questions sur les tableaux Java

1. Pouvons-nous spécifier la taille du tableau aussi longtemps ?

Non, nous ne pouvons pas spécifier la taille du tableau aussi longue, mais nous pouvons la spécifier comme int ou short.

2. Quelle est la superclasse directe d’un tableau en Java ?

Un Objet est une superclasse directe d'un tableau en Java.

3. Quelles interfaces sont implémentées par les tableaux en Java ?

Chaque type de tableau implémente les interfaces Cloneable et java.io.Sérialisable .

4. Pouvons-nous modifier la taille du tableau ?

La taille du tableau ne peut pas être modifiée (une fois initialisée). Cependant, une référence à un tableau peut être faite pour pointer vers un autre tableau.

Articles connexes au sujet

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