Un tableau est une collection de variables du même type désignées par un nom commun. Les tableaux peuvent être créés à partir d’éléments de n’importe quel type et peuvent avoir une ou plusieurs dimensions. Un élément spécifique d'un tableau est accessible par son index (numéro). Dans cette note, nous examinerons le traitement des tableaux unidimensionnels et bidimensionnels.

Tableaux unidimensionnels en Java

Un tableau unidimensionnel est essentiellement une liste de variables du même type. Pour créer un tableau, vous devez d'abord créer une variable tableau du type souhaité. Le format général pour déclarer un tableau unidimensionnel est :
tapez nom-var ;
Ici, type déclare le type sous-jacent du tableau ; var-name est le nom de la variable du tableau. Le type de base détermine le type de données de chaque élément du tableau. Par exemple, une déclaration d'un tableau unidimensionnel de composants int nommémonth_days ressemble à :
int mois_jours ;
Bien que cette déclaration établisse le fait quemonth_days est une variable tableau, aucun tableau n'existe réellement. En fait,month_days est défini sur null (pointeur nul), ce qui représente un tableau sans valeur. Pour associer mois_jours à un tableau physique réel d'entiers, vous devez lui allouer de la mémoire à l'aide de la nouvelle opération et l'attribuer au tableau mois_jours ; new est une opération spéciale qui alloue de la mémoire.

Le format général de new appliqué aux tableaux unidimensionnels est :
array-var = nouveau type ;
où type est le type de données distribuées, size est le nombre d'éléments dans le tableau, array-var est une variable associée au tableau. Pour utiliser new pour allouer de la mémoire à un tableau, vous devez spécifier le type et le nombre d'éléments du tableau. Les éléments du tableau alloués avec la nouvelle opération seront automatiquement initialisés à zéro. L'exemple suivant alloue de la mémoire pour un tableau d'entiers de 12 éléments et l'associe à la variablemonth_days.
mois_jours = nouveau int ;
Une fois cette instruction exécutée,month_days fera référence à un tableau de douze nombres entiers. Ensuite, tous les éléments du tableau seront initialisés à zéro.
Le processus d'obtention d'un tableau comporte deux étapes. Tout d’abord, vous devez déclarer une variable tableau du type souhaité. Deuxièmement, vous devez allouer la mémoire qui contiendra le tableau à l'aide de la nouvelle opération et l'attribuer à une variable de tableau. Ainsi, dans Java tous les tableaux sont alloués dynamiquement.

Une fois que vous avez alloué de la mémoire à un tableau, vous pouvez accéder à un élément spécifique de celui-ci en spécifiant un index entre crochets. La numérotation des éléments du tableau commence à zéro. Les noms de tableaux sont des références.

Combinaison d'annonces possible type de variable un tableau avec allocation de mémoire au tableau directement dans la déclaration :
int mois_jours = nouveau int;

Considérons le code d'un programme qui remplace les éléments négatifs d'un tableau par l'élément maximum :

Classe publique FindReplace ( public static void main(String args) ( int myArray; // déclaration sans initialisation int mySecond = new int; /* allocation de mémoire avec initialisation aux valeurs par défaut */ int a = (5, 10, 0, -5 , 16, -2); // déclaration avec initialisation int max = a; for (int i = 0; i< a.length; i++) { if (a[i]<0) a[i] = max; mySecond[i] = a[i]; System.out.println("a[" + i + "]=" + a[i]); } myArray = a; // установка ссылки на массив a } }

Le résultat de l'exécution sera :

>java FindReplace a=5 a=10 a=0 a=5 a=16 a=5

L'attribution de mySecond[i] = a[i] fera qu'une partie des éléments du tableau mySecond , à savoir six, se verra attribuer les valeurs des éléments du tableau a . Les éléments restants de mySecond conserveront les valeurs obtenues lors de l'initialisation, c'est-à-dire des zéros. Si l'affectation est organisée sous la forme mySecond = a ou myArray = a, alors les deux tableaux participant à l'affectation recevront une référence au tableau a, c'est-à-dire qu'ils contiendront tous deux six éléments et feront référence au même emplacement mémoire.
Les tableaux peuvent être initialisés au moment où ils sont déclarés. Le processus est sensiblement le même que celui utilisé pour initialiser des types simples. Un initialiseur de tableau est une liste d’expressions séparées par des virgules et entourées d’accolades. Le tableau sera automatiquement créé suffisamment grand pour contenir autant d'éléments que vous spécifiez dans l'initialiseur du tableau. Il n'est pas nécessaire d'utiliser la nouvelle opération. Par exemple, pour stocker le nombre de jours de chaque mois, le code suivant crée un tableau d'entiers initialisé :

Classe publique MonthDays ( public static void main(String args) ( int Month_days = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31); System.out.println("Avril contient " + mois_jours + " jours. "); ) )

À la suite de l'exécution du programme, les éléments suivants seront affichés à l'écran :

Avril contient 30 jours.

Commentaire: Java effectue des contrôles stricts pour s'assurer que vous n'essayez pas accidentellement de stocker ou de lire des valeurs en dehors de la zone de stockage de la baie. Système exécutif Java effectue également des vérifications minutieuses pour s'assurer que tous les indices de tableau sont dans la plage correcte. (À cet égard Java diffère considérablement des langues C/C++, qui ne fournissent pas de vérification des limites d'exécution).

Tableaux multidimensionnels en Java

DANS Tableaux multidimensionnels Java sont, en fait, des tableaux de tableaux. Ils ressemblent et agissent comme des tableaux multidimensionnels réguliers. Il existe cependant quelques différences subtiles. Pour déclarer une variable tableau multidimensionnelle, définissez chaque index supplémentaire à l’aide d’un ensemble différent de crochets. Par exemple, l'instruction suivante déclare une variable tableau bidimensionnel nommé deuxD :
int deuxD = nouveau int;
Il alloue de la mémoire pour un tableau 4x5 et l'assigne à la variable twoD. En interne, cette matrice est implémentée sous la forme d'un tableau de tableaux d'entiers de type int .
Les tableaux multidimensionnels peuvent être initialisés. Pour ce faire, incluez simplement l'initialiseur de chaque dimension dans son propre ensemble d'accolades.
Le programme suivant crée et initialise des tableaux de tableaux longueur égale(matrices), et le produit d'une matrice par une autre s'effectue :

Classe publique Matrix ( private int a; Matrix(int ​​​​n, int m) ( // création et remplissage aléatoire a = new int[n][m]; for (int i = 0; i< n; ++i) for (int j = 0; j < m; ++j) a[i][j] = (int) (Math.random()*5); show(); } public Matrix(int n, int m, int k) { // создание и заполнение с random a = new int[n][m]; for (int i = 0; i < n; ++i) for (int j = 0; j < m; ++j) a[i][j] = k; if (k != 0) show(); } public void show() { System.out.println("Матрица:" + a.length + " на " + a.length); for (int i = 0; i < a.length; ++i) { for (int j = 0; j < a.length; ++j) System.out.print(a[i][j] + " "); System.out.println(); } } public static void main(String args) { int n = 2, m = 3, z = 4; Matrix p = new Matrix(n, m); Matrix q = new Matrix(m, z); Matrix r = new Matrix(n, z, 0); for (int i = 0; i < p.a.length; ++i) for (int j = 0; j < q.a.length; ++j) for (int k = 0; k < p.a[i].length; ++k) r.a[i][j] += p.a[i][k]*q.a[k][j]; System.out.println("Произведение матриц: "); r.show(); } }

Étant donné que les valeurs sont attribuées aux éléments du tableau à l'aide de la méthode random(), l'une des options d'exécution du code pourrait être la suivante :

> javac Matrix.java > java Matrix Matrix:2 par 3 3 2 0 3 3 1 Matrix:3 par 4 1 2 2 3 3 2 3 2 1 2 3 2 Produit de matrices: Matrix:2 par 4 9 10 12 13 13 14 18 17

L'exemple suivant illustre la copie d'un tableau :

Classe publique ArrayCopyDemo ( public static void main(String args) ( int mas1 = (1,2,3), mas2 = (4,5,6,7,8,9); System.out.print("mas1: " ); show(mas1); System.out.print("mas2: "); show(mas2); // copie du tableau mas1 vers mas2 System.arraycopy(mas1, 0, mas2, 2, 3); /* 0 - mas1 est copié à partir de l'élément zéro * 2 - l'élément à partir duquel le remplacement commence * 3 - le nombre d'éléments à copier */ System.out.println("\n after arraycopy(): "); System.out .print("mas1: " ); show(mas1); System.out.print("\nmas2: "); show(mas2); ) private static void show(int mas) ( pour (int i = 0; i< mas.length; ++i) System.out.print(" " + mas[i]); } }

Résultat de l'exécution du programme :

> javac ArrayCopyDemo.java > java ArrayCopyDemo mas1 : 1 2 3mas2 : 4 5 6 7 8 9 après arraycopy() : mas1 : 1 2 3 mas2 : 4 5 1 2 3 9

Syntaxe de déclaration de tableau alternative

Il existe une autre forme qui peut être utilisée pour déclarer un tableau :
tapez nom-var ;
Ici, les crochets suivent le spécificateur de type plutôt que le nom de la variable du tableau. Par exemple, les deux déclarations suivantes sont équivalentes :

Int al = nouvel int ; int a2 = nouvel int ;
Les déclarations présentées ici sont également équivalentes :
char twodi = nouveau caractère ; char twod2 = nouveau caractère ;
Cette forme alternative d'annonce est incluse principalement pour des raisons de commodité.

Un tableau est un ensemble d’objets du même type qui portent un nom commun. Chaque élément du tableau est accessible par son index. Considérons exemple réel. Disons un certain entrepôt appelé a et contenons-lui un certain nombre de boîtes, dont chacune est numérotée séquentiellement. Chaque boîte contient un objet du même type que les objets des autres boîtes. Un exemple de cet entrepôt est un tableau classique, où le nom de l'entrepôt est le nom du tableau, les boîtes sont les éléments du tableau, les numéros de boîte sont les indices des éléments et le contenu des boîtes est le valeurs de nos variables. Imaginons qu'il y ait des citrons à l'intérieur des boîtes, et que dans chaque boîte il y a une certaine quantité de citrons. Ensuite, les valeurs de nos variables afficheront le nombre de citrons. Considérons un entrepôt composé de trois boîtes, que la première boîte en contienne 3, la deuxième 7 et la troisième 273. Ensuite, le tableau décrivant cet entrepôt peut être représenté comme suit :

Indice	0	1	2
Signification	3	7	273

L'indexation dans un tableau commence toujours à 0. Examinons quelques opérations qui peuvent être effectuées avec un tableau :

Création d'un tableau

TypeVariableName ;
int a;//tableau entier
char b;//tableau de caractères
Chaîne c ;

Allocation de mémoire :

A = new int ; // allouer de la mémoire pour 10 éléments
b = new char; // allouer de la mémoire pour 20 éléments
c = new String; // allouer de la mémoire pour 30 éléments

Ainsi, l'initialisation du tableau ressemble à ceci :

Int a = new int;//initialisation d'un tableau d'entiers avec 10 éléments
char b = new char;//initialisation d'un tableau de caractères de 20 éléments
String c = new String;//initialisation d'un tableau de chaînes de 30 éléments

Tous les éléments du tableau après une telle initialisation se voient attribuer une valeur par défaut.
Il est possible de fixer immédiatement les valeurs des éléments du tableau ; créons un tableau qui affichera le nombre de citrons dans la boîte, comme dans l'exemple ci-dessus :

Int a = nouveau int( 3, 7, 273 );

Travailler avec un tableau

Lecture d'un tableau :

Importer java.util.Scanner ;
test de classe publique (
public static void main (arguments de chaîne) (
int a;//tableau d'entiers
int n;//nombre d'éléments dans le tableau
Scanner dans = nouveau scanner (System.in);
n = in.nextInt();
a = nouveau int[n] ;
for(int i = 0; i Modification des valeurs du tableau :

for(int i = 0; i Sortie du tableau :

Int a ; // un tableau d'entiers qui a été traité d'une manière ou d'une autre
for(int i = 0; i Accès aléatoire à un élément du tableau par index :

System.out.println(a);//Imprimer le premier élément du tableau
a = 1;//Attribuer 1 au deuxième élément du tableau
int temp = a;//Enregistre la valeur du troisième élément du tableau dans la variable temp

Voici à quoi ressemblent les opérations de base avec les tableaux. Très souvent, dans divers cours d'informatique, il leur est demandé de diviser ces étapes de travail avec un tableau en fonctions distinctes, mais nous en reparlerons plus tard. Ainsi, en lisant un tableau, on peut saisir certaines valeurs depuis la console, en changeant les valeurs, on peut, par exemple, augmenter toutes les valeurs d'un ou multiplier par deux, et en utilisant la sortie, on peut afficher la valeur actuelle valeurs du tableau. Si nous devons travailler uniquement avec des éléments spécifiques d'un tableau, nous pouvons alors utiliser l'accès aléatoire par index, où index est tout entier positif inférieur à la longueur du tableau. La longueur actuelle du tableau peut être obtenue à l'aide de la propriété length ; elle a déjà été utilisée lors de l'affichage du tableau.
Ici, j'omettrai le dialogue sur le fait que les tableaux sont des références et que travailler avec eux diffère de travailler avec des types de base ordinaires.

Tableaux bidimensionnels

Il n'est pas toujours pratique de numéroter les cartons dans un entrepôt de 0 à un certain nombre, vous souhaitez parfois donner à l'entrepôt une forme plus ordonnée, par exemple en introduisant des rangées. Désormais, chaque boîte a son propre numéro de ligne et son propre numéro de série dans cette ligne. Supposons qu'il y ait neuf cartons dans notre entrepôt contenant 1, 2, et ainsi de suite 9 oranges. Les cartons de l'entrepôt sont disposés en trois rangées de trois cartons, la situation dans l'entrepôt peut alors être imaginée comme suit.

19 réponses

Vous pouvez utiliser une déclaration de tableau ou un littéral de tableau (mais uniquement lorsque vous déclarez et affectez immédiatement une variable ; les littéraux de tableau ne peuvent pas être utilisés pour réaffecter un tableau).

Pour les types primitifs :

Int monIntArray = new int; int monIntArray = (1,2,3); int monIntArray = new int(1,2,3);

Pour les classes comme String c'est pareil :

Chaîne myStringArray = nouvelle chaîne ; String myStringArray = ("a", "b", "c"); String myStringArray = new String("a","b","c");

La troisième méthode d'initialisation est utile lorsque vous déclarez d'abord un tableau, puis que vous l'initialisez. Un casting est nécessaire ici.

Chaîne monStringArray ; monArrayChaîne = new String("a","b","c");

Il existe deux types de tableaux.

Tableau unidimensionnel

Syntaxe de valeur par défaut :

Int num = nouvel int ;

Ou (moins préféré)

Int num = nouvel int ;

Syntaxe avec les valeurs spécifiées (initialisation variable/champ) :

Numéro int = (1,2,3,4,5);

Ou (moins préféré)

Numéro int = (1, 2, 3, 4, 5);

Note. Pour plus de commodité, int num est préféré car il indique clairement que vous parlez ici d’un tableau. Sinon, il n'y a aucune différence. Pas du tout.

Tableau multidimensionnel

Déclaration

int num = nouvel int ;

Int num = nouvel int ;

Int num = nouvel int ;

Initialisation

num=1 ; nombre=2 ; num=1 ; nombre=2 ; num=1 ; nombre=2 ; num=1 ; nombre=2 ; num=1 ; nombre=2 ;

Int num=( (1,2), (1,2), (1,2), (1,2), (1,2) );

Ragged Array (ou tableau non rectangulaire)

int num = nouvel int ; num = nouveau int; num = nouveau int; num = nouveau int; num = nouveau int;

Nous définissons donc ici explicitement les colonnes.
Autrement:

Int num=( (1), (1,2), (1,2,3,4,5), (1,2), (1,2,3) );

Accéder:

pour (int je=0; je<(num.length); i++) { for (int j=0;jComme alternative:

Pour (int a: num) ( for (int i: a) ( System.out.println(i); ) )

Tapez nomvariable = nouveau type ; Tapez variableName = (valeurs délimitées par des virgules) ; Tapez nomvariable = nouveau type ; Tapez variableName = (valeurs délimitées par des virgules) ;

est également valide, mais je préfère les parenthèses après le type car il est plus facile de voir que le type de la variable est en fait un tableau.

Ce qui suit montre une déclaration de tableau, mais le tableau n'est pas initialisé :

Int monIntArray = new int;

Ci-dessous la déclaration ainsi que l'initialisation du tableau :

Int monIntArray = (1,2,3);

Maintenant, ce qui suit montre également la déclaration ainsi que l'initialisation du tableau :

Int monIntArray = new int(1,2,3);

Mais ce troisième montre la propriété de création anonyme d'un objet tableau, qui est indiquée par la variable de référence "myIntArray", donc si on écrit seulement "new int(1,2,3);" alors il peut s'agir d'un objet tableau anonyme.

Si on écrit simplement :

Int monIntArray ;

Il ne s'agit pas d'une déclaration de tableau, mais l'instruction suivante complète l'expression suivante :

MyIntArray=nouvel int ;

Je trouve utile si vous comprenez chaque partie :

Nom du type = nouveau type ;

Type est le type d'une variable appelée nom ("nom" est appelé un identifiant). Le "Type" littéral est le type de base, et les parenthèses signifient qu'il s'agit du type tableau de cette base. Les types de tableaux, à leur tour, sont leurs propres, ce qui vous permet de créer des tableaux multidimensionnels de type Type ( type de tableau Type ). Le mot-clé new fait référence à l'allocation de mémoire pour un nouveau tableau. Le nombre entre parenthèses indique la taille du nouveau tableau et la quantité de mémoire qui sera allouée. Par exemple, si Java sait que le type sous-jacent est de 32 octets et que vous souhaitez un tableau de taille 5, il doit allouer en interne 32 * 5 = 160 octets.

Vous pouvez également créer des tableaux avec des valeurs déjà existantes, telles que

Nom int = (1, 2, 3, 4, 5);

ce qui non seulement crée un espace vide, mais le remplit également de ces valeurs. Java peut dire que les primitives sont des entiers et qu'il y en a 5, la taille du tableau peut donc être déterminée implicitement.

De plus, si vous souhaitez quelque chose de plus dynamique, il existe l'interface List. Cela ne fonctionnera pas, mais c'est plus flexible :

Liste listOfString = nouveau ArrayList (); listOfString.add("foo"); listOfString.add("bar"); Valeur de chaîne = listOfString.get(0); assertEquals(valeur, "foo");

Il existe deux manières principales de créer un tableau :

Celui-ci, pour un tableau vide :

Tableau int = nouveau int[n]; // "n" étant le nombre d'espaces à allouer dans le tableau

Et celui-ci, pour un tableau initialisé :

Tableau int = (1,2,3,4 ...);

Vous pouvez également créer des tableaux multidimensionnels, par exemple :

Int array2d = nouveau int[x][y]; // "x" et "y" précisent les dimensions int array2d = ( (1,2,3 ...), (4,5,6 ...) ...);

Prenons par exemple le type primitif int. Il existe plusieurs manières de déclarer un tableau int :

Int i = nouvel int ; int i = nouvel int (valeur1, valeur2, valeur3, etc.); int i = (valeur1, valeur2, valeur3, etc.);

où dans tous ces cas, vous pouvez utiliser int i au lieu de int i .

Avec la réflexion, vous pouvez utiliser (Type) Array.newInstance(Type.class,capacité);

Notez que les paramètres de la méthode... affichent des arguments variables . Fondamentalement, n’importe quel nombre de paramètres convient. C'est plus facile à expliquer avec du code :

Public static void varargs(intfixed1, Stringfixed2, int... varargs) (...) ... varargs(0, "", 100); // fixe1 = 0, fixe2 = "", varargs = (100) varargs(0, "", 100, 200); // fixe1 = 0, fixe2 = "", varargs = (100, 200);

Dans la méthode, varargs est traité comme un entier normal. Type... ne peut être utilisé que dans les paramètres de méthode, donc int... i = new int() ne sera pas compilé.

Notez que lorsque vous passez un int à une méthode (ou à tout autre type), vous ne pouvez pas utiliser la troisième méthode. Dans l'instruction int i = *(a, b, c, d, etc)*, le compilateur suppose que (...) signifie int . Mais c'est parce que vous déclarez une variable. Lors du passage d'un tableau à une méthode, la déclaration doit être soit new Type, soit new Type (...) .

Tableaux multidimensionnels

Les tableaux multidimensionnels sont beaucoup plus difficiles à gérer. Essentiellement, un tableau 2D est un tableau de tableaux. int signifie un tableau de int s. La clé est que si un int est déclaré comme int[x][y] , l'index maximum est i . Essentiellement, un rectangle int est égal à :

Déclaration d'un tableau de références d'objets :

Class Animal () class Horse extends Animal ( public static void main(String args) ( /* * Le tableau d'Animal peut contenir Animal et Horse (tous les sous-types d'Animal autorisés) */ Animal a1 = new Animal; a1 = new Animal() ; a1 = new Horse(); /* * Le tableau d'animaux peut contenir des animaux, des chevaux et tous les sous-types de chevaux */ Animal a2 = new Horse; a2 = new Animal(); a2 = new Horse(); /* * Array de Cheval ne peut contenir que le Cheval et son sous-type (le cas échéant) et n'est pas autorisé le supertype de Cheval ni tout autre sous-type d'Animal. */ Cheval h1 = new Horse; h1 = new Animal(); // Non autorisé h1 = new Horse() ; /* * Cela ne peut pas être déclaré. */ Cheval h2 = new Animal; // Non autorisé ) )

Un tableau est une liste séquentielle d'éléments

Int élément = valeur ; int one_dimensionnel_array = ( valeur, valeur, valeur, .., valeur ); int two_dimensionnel_array = ( ( valeur, valeur, valeur, .. valeur ), ( valeur, valeur, valeur, .. valeur ), .. .. .. .. ( valeur, valeur, valeur, .. valeur ) );

Si c'est un objet, alors c'est le même concept

Élément d'objet = new Object(); Objet one_dimensionnel_array = ( new Object(), new Object(), .. new Object() ); Objet two_dimensionnel_array = ( ( new Object(), new Object(), .. new Object() ), ( new Object(), new Object(), .. new Object() ), .. .. .. ( new Objet(), nouvel Objet(), .. nouvel Objet() ) );

Dans le cas d'objets, vous devez soit l'attribuer à null pour l'initialisation à l'aide de new Type(..) , les classes comme String et Integer sont des cas particuliers qui seront traités comme suit

String a = ("bonjour", "monde" ); // est équivalent à String a = ( new String(("h","e","l","l","o")), new String(("w","o","r" ,"l","d")) ); Entier b = ( 1234, 5678 ); // est équivalent à Integer b = ( new Integer(1234), new Integer(5678) );

En général, vous pouvez créer des tableaux de dimension M

Int .. array = // ^ M fois parenthèses ((..( // ^ M fois ( parenthèse // ceci est un tableau.. // ^ M fois ))..) // ^ M fois ) parenthèse ;

Il convient de noter que la création d'un tableau dimensionnel M coûte cher d'un point de vue spatial. Parce que lorsque vous créez un tableau M avec N dans toutes les dimensions, la taille totale du tableau est supérieure à N^M , puisque chaque tableau a un lien, et dans la dimension M il y a un tableau dimensionnel (M -1) de liens. La taille globale est la suivante

Un tableau est une structure de données qui stocke des valeurs du même type. Un élément de tableau individuel est accessible à l’aide d’un index entier. Par exemple, si a est un tableau d’entiers, alors la valeur de l’expression a[i] est égale au i-ème entier du tableau. Un tableau est déclaré comme suit : d'abord, le type du tableau est indiqué, c'est-à-dire le type des éléments contenus dans le tableau, suivi d'une paire de crochets vides, puis du nom de la variable. Par exemple, voici comment déclarer un tableau composé d'entiers : int a; Cependant, cette instruction déclare uniquement la variable a, sans l'initialiser avec un tableau réel. Pour créer un tableau, vous devez utiliser l'opérateur new. int a = nouveau int [ 100 ] ; Cet opérateur crée un tableau de 100 entiers. Les éléments de ce tableau sont numérotés de 0 à 99 (et non de 1 à 100). Une fois créé, le tableau peut être rempli, par exemple, à l'aide d'une boucle. int a = nouveau int [ 100 ] ; pour (int je = 0 ; je< 100 ; i++ ) a[ i] = i; //Remplit le tableau avec des nombres de 0 à 99 Si vous essayez d'accéder à l'élément a (ou à tout autre élément dont l'index est en dehors de la plage 0 à 99) en créant un tableau de 100 éléments, le programme se terminera car une exception d'index de tableau hors plage sera levée. Pour compter le nombre d'éléments dans un tableau, utilisez la méthode Arrayname.length. Par exemple, pour (int i = 0 ; i< a. length; i++ , System. out. println (a[ i] ) ) ; После создания массива изменить его размер невозможно (хотя можно, конечно, изменять отдельные его элементы). Если в ходе выполнения программы необходимо часто изменять размер массива, лучше использовать другую структуру данных, называемую списком массивов (array list). Массив можно объявить двумя способами: int a; или int a ; Большинство программистов на языке Java предпочитают первый стиль, поскольку в нем четче отделяется тип массива int (целочисленный массив) от имени переменной.

Initialiseurs de tableau et tableaux sans nom

Java dispose d'une fonctionnalité permettant de créer simultanément un tableau et de l'initialiser. Voici un exemple d'une telle construction syntaxique : int smallPrimes = (2, 3, 5, 7, 11, 13) ; Notez que dans ce cas, il n’est pas nécessaire d’utiliser l’opérateur new. De plus, vous pouvez même initialiser un tableau sans nom : new int (16, 19, 23, 29, 31, 37) Cette expression alloue de la mémoire pour un nouveau tableau et le remplit avec les nombres spécifiés entre accolades. Dans ce cas, leur nombre est calculé et, en conséquence, la taille du tableau est déterminée. Cette construction syntaxique est pratique à utiliser pour réinitialiser un tableau sans créer de nouvelle variable. Par exemple, l'expression smallPrimes = new int (17, 19, 23, 29, 31, 37) ; est une version abrégée de l'expression int anonyme = (17, 19, 23, 29, 31, 37) ; smallPrimes = anonyme ; Vous pouvez créer un tableau de taille nulle. Un tel tableau peut être utile lors de l’écriture d’une méthode qui évalue un tableau qui s’avère vide. Un tableau de longueur nulle est déclaré comme suit : new Type d'élément Notez qu'un tel tableau n'est pas équivalent à un objet nul.

Copie de tableaux

Un tableau peut être copié dans un autre, mais les deux variables feront référence au même tableau. int LuckyNumbers = smallPrimes; LuckyNumbers[ 5 ] = 12 ; //Maintenant, l'élément smallPrimes vaut également 12 Le résultat est présenté sur la Fig. 3.1. Si vous devez copier tous les éléments d'un tableau vers un autre, vous devez utiliser la méthode arraycopy de la classe System. Son appel ressemble à ceci : Système. arraycopy (de, fromlndex, to, tolndex, count) ; Le tableau to doit être suffisamment grand pour contenir tous les éléments à copier. Figure 3.1. Copier un tableau Par exemple, les opérateurs présentés ci-dessous, dont les résultats sont présentés sur la Fig. 3.2, créez deux tableaux puis copiez les quatre derniers éléments du premier tableau dans le second. La copie commence à partir de la deuxième position dans le tableau source et les éléments copiés sont placés dans le tableau cible à partir de la troisième position. int smallPrimes = (2, 3, 5, 7, 11, 13); int LuckyNumbers = (1001, 1002, 1003, 1004, 1005, 1006, 1007) ; Système. appareil (smallPrimes, 2, LuckyNumbers, 3, 4) ; pour (int je = 0 ; je< luckyNumbers. length; i++ ) System. out. println (i + ": " + luckyNumbers[ i] ) ; Выполнение этих операторов приводит к следующему результату. 0 : 1001 1 : 1002 2 : 1003 3 : 5 4 : 7 5 : 11 6 : 13 Riz. 3.2. Copie d'éléments de tableau Un tableau en Java est très différent d’un tableau en C++. Cependant, c’est pratiquement la même chose qu’un pointeur vers un tableau dynamique. Cela signifie que l'opérateur int a = new int [ 100 ] ; //Java équivalent à l'opérateur int * = new int [ 100 ] ; //C++, pas int a[ 100 ] ; //C++ Dans le langage Java, l'opérateur par défaut vérifie la plage des modifications d'index. De plus, Java n'a pas d'arithmétique de pointeur : vous ne pouvez pas incrémenter un pointeur pour accéder à l'élément suivant d'un tableau. Lien vers le premier

Qu'est-ce qu'un tableau ?

Un tableau en Java est une collection d’éléments du même type accessibles par index.

Les éléments du tableau en Java sont situés les uns après les autres dans la mémoire de l'ordinateur. Vous trouverez ci-dessous un exemple de tableau en Java.

Déclarer un tableau en Java

Déclarons un tableau pour stocker les éléments de type int :

Ici, la variable arr est déclarée, qui est un tableau. Pour utiliser cette variable, vous devez la définir.

Définition de tableau en Java

Pour définir un tableau en Java, vous devez spécifier sa longueur, c'est-à-dire nombre d'éléments pouvant y être stockés :

Notre tableau stockera 5 éléments.

Un tableau est une collection d'éléments. Chaque élément du tableau peut être référencé par son numéro. Le numéro est généralement appelé un index. La numérotation des éléments du tableau en Java commence à zéro.

Comment charger des éléments dans un tableau ?

Attribuons une valeur au premier élément du tableau, et le premier élément a l'indice zéro :

Attribuons une valeur au deuxième élément du tableau, et le deuxième élément a l'indice un :

pour (int auberge = 0; auberge< 5; inn++)
{
arr = auberge;
}

Lors de la déclaration d'un tableau, vous pouvez immédiatement y charger des valeurs :

int arr = (0, 1, 2, 3, 4);

le nombre d'éléments ici est de 5, c'est-à-dire Il n’est pas nécessaire de préciser le nombre d’éléments, il sera déterminé automatiquement.

Comment récupérer les éléments d'un tableau ?

Chaque élément du tableau peut être référencé par son numéro. Pour obtenir un élément de tableau, vous devez spécifier le nom du tableau et l'index de l'élément :

Il s'agit du premier élément du tableau, car le premier élément a l'indice zéro.

Attribuons la valeur du troisième élément du tableau à la variable int a :

Sortons tous les éléments du tableau dans une boucle (nous allons parcourir le tableau) :

Pour (int auberge = 0; auberge< 5; inn++) { System.out.println("arr[" + inn + "] = " + arr); }

Une version simplifiée de la boucle pour générer un tableau est la suivante :

Pour(int inn: arr) ( System.out.println("arr[" + inn + "] = " + arr); )

Comment supprimer un tableau en Java ?

Vous pouvez supprimer un tableau en Java comme ceci :

Comment obtenir la longueur d’un tableau en Java ?

Nous obtenons la longueur d'un tableau en Java comme ceci :

int arrLength = arr.length;

Comment obtenir le premier élément d’un tableau en Java ?

int firstElem = arr;

Comment obtenir l'avant-dernier élément d'un tableau en Java ?

int lastElem = arr;

Comment définir un tableau de longueur variable en Java ?

Comment définir un tableau de longueur variable en Java ? Certainement pas. Lorsque vous définissez un tableau, vous définissez ensuite sa longueur ; elle ne peut pas être modifiée ultérieurement. Dans de tels cas, des collections sont utilisées, par exemple : Vector, ArrayList, etc.

Ainsi, la longueur du tableau ne peut pas être variable. Mais vous pouvez utiliser une variable lors de la définition d'un tableau. Le cas échéant:

CD entier ;
int ab = new int;//Erreur.

alors nous obtenons une erreur : la longueur du tableau ne peut pas être une variable.

Vous devez définir la valeur cd :

int cd = 10 ;
int ab = nouvel int ;

Tout va bien maintenant. Si vous modifiez la variable cd après avoir défini le tableau, cela n'affectera pas le tableau, c'est-à-dire sa longueur ne changera pas. Exemple:

CD int = 10 ; int ab = nouvel int ; cd = 12;// C'est possible arrLength = ab.length; System.out.println("ab array length = " + arrLength); //Sorties : ab longueur du tableau = 10 ab=4;// Et voici l'erreur

Nous obtenons une erreur :

Exception dans le thread « principal » java.lang.ArrayIndexOutOfBoundsException : 11

L'indice maximum de notre tableau est 9. Changer la valeur de la variable cd n'affecte pas le tableau, car il est déjà défini et sa longueur est constante.

Les variables peuvent être utilisées pour accéder aux éléments du tableau :

Int var = 1 ;
int elem = arr;
var = 2 ;
elem = arr;

Tableau de caractères en Java

Un exemple de tableau de caractères en Java et sa sortie :

Char charArr = ("S", "B", "P"); pour (int auberge = 0; auberge< charArr.length; inn++) { System.out.println("charArr[" + inn + "] = " + charArr); }

Comment remplir un tableau en Java ?

Vous pouvez remplir un tableau en utilisant la méthode de remplissage statique.