Tableau Java à 2 dimensions. Tableau Java. Tableaux en Java. Java pour les débutants

Java,

Algorithmes

• Tutoriel

Je pense que peu de ceux qui préparent leur premier entretien, lorsqu'ils postulent pour leur premier emploi de programmeur (pré)junior, répondront à cette question par la négative. Ou du moins douter de la réponse positive. Bien sûr, une structure de données aussi simple avec un accès direct à l'index - pas de trucs ! Non, dans certains langages comme JavaScript ou PHP, les tableaux sont bien sûr implémentés de manière très intéressante et sont essentiellement bien plus qu'un simple tableau. Mais il ne s'agit pas de cela, mais de la mise en œuvre « traditionnelle » de tableaux sous la forme d'un « morceau de mémoire continue ». Dans ce cas, en fonction des indices et de la taille d'un élément, l'adresse est simplement calculée et on accède à la valeur correspondante. Qu’y a-t-il de si difficile là-dedans ?
Voyons cela. Par exemple, en Java. Demander à un candidat sans méfiance de créer un tableau d'entiers n x n. La personne écrit avec assurance quelque chose comme :
int g = nouveau int[n][n];
Super. Nous vous demandons maintenant d'initialiser les éléments du tableau avec quelque chose. Au moins en unités, au moins en somme d'indices. On obtient :
pour (int je = 0; je< n; i++) { for(int j = 0; j < n; j++) { g[i][j] = i + j; } }
Ils écrivent même plus souvent
pour (int je = 0; je< g.length; i++) { for(int j = 0; j < g[i].length; j++) { g[i][j] = i + j; } }
ce qui est aussi un motif de conversation, mais maintenant nous parlons d'autre chose. Nous essayons de découvrir ce qu'une personne sait et de voir comment elle pense. Nous attirons donc son attention sur le fait que les valeurs sont situées symétriquement et lui demandons de sauvegarder sur les itérations de boucle. Bien sûr, pourquoi parcourir toutes les valeurs de l’indice alors qu’on ne peut parcourir que le triangle du bas ? Le sujet s'accorde généralement facilement et, en soulignant judicieusement la diagonale principale, écrit soigneusement quelque chose comme :
pour (int je = 0; je< n; i++) { g[i][i] = 2* i; for(int j = 0; j < i; j++) { g[j][i] = g[i][j] = i + j; } }
Au lieu de g[i][i] = 2* i;<< 1; и это тоже повод поговорить. Но мы идем дальше и задаем ключевой вопрос: souvent écrit g[i][i] = i + i; ou g[i][i] = je
À quelle vitesse le programme fonctionnera-t-il ? n. Le raisonnement habituel est le suivant : presque 2 fois moins de calculs d'indices ; presque 2 fois moins de calculs de valeurs (somme) ; le même nombre de missions. Cela signifie 30 % plus rapide. Si une personne a une bonne formation en mathématiques, vous pouvez même voir le nombre exact d'opérations enregistrées et une évaluation plus raisonnée de l'efficacité de l'optimisation.

L’heure est désormais au coup dur. Nous exécutons les deux versions du code sur une valeur suffisamment grande

classe A ( public static void main(String args) ( int n = 8000; int g = new int[n][n]; long st, en; // un st = System.nanoTime(); for(int i = 0 ;< n; i++) { for(int j = 0; j < n; j++) { g[i][j] = i + j; } } en = System.nanoTime(); System.out.println("\nOne time " + (en - st)/1000000.d + " msc"); // two st = System.nanoTime(); for(int i = 0; i < n; i++) { g[i][i] = i + i; for(int j = 0; j < i; j++) { g[j][i] = g[i][j] = i + j; } } en = System.nanoTime(); System.out.println("\nTwo time " + (en - st)/1000000.d + " msc"); } }

Que voit-on ? La version optimisée fonctionne 10 à 100 fois plus lentement ! Il est désormais temps d'observer la réaction du candidat face au poste. Quelle sera la réaction à une situation stressante inhabituelle (plus précisément habituelle dans la pratique du développeur). Si le visage de l'accusé montre de l'excitation et qu'il commence à appuyer sur des boutons, oubliant temporairement votre existence, alors c'est bon signe. Dans une certaine mesure. Vous ne voulez pas embaucher un chercheur qui ne se soucie pas du résultat du projet, n'est-ce pas ? Alors ne lui posez pas la question « Pourquoi ? Demandez-leur de retravailler la deuxième option pour qu’elle fonctionne plus rapidement que la première.
Vous pouvez désormais vaquer à vos occupations en toute sécurité pendant un moment. En une demi-heure, vous disposerez de suffisamment de matériel pour évaluer les qualités personnelles et professionnelles de base du candidat.
À propos, lorsque j'ai brièvement décrit ce problème sur mon site Web professionnel, le commentaire le plus populaire était « Voici votre courbe Java ». Je publie le code sur Great and Free spécialement pour eux. Et les heureux propriétaires de Free Pascal pour Windows peuvent y jeter un œil

sous le spoiler

Durée du programme ; utilise Windows ;

var début, fin, res : int64 ;
n, i, j : nombre entier ;
g : Tableau de Tableau d’entiers ; début n := 10 000 ;
DéfinirLongueur(g, n, n);

QueryPerformanceFrequency(res); n QueryPerformanceCounter(début);
Au fait, est-ce que tout le monde comprend ce qui se passe ?

Quelques mots de justification

Je voudrais dire quelques mots pour justifier cette méthode d’entretien d’embauche. Oui, je ne teste pas la connaissance de la syntaxe du langage et la connaissance des structures de données. Peut-être que dans un marché du travail civilisé, tout cela fonctionne. Mais dans nos conditions de pénurie totale de personnel qualifié, nous devons plutôt évaluer l'adéquation à long terme du candidat au travail auquel il sera confronté. Ceux. la capacité d’apprendre, de percer, de comprendre, de faire.
Cet esprit est similaire à « l’entretien » pour le recrutement de légionnaires dans la Rome antique. Le futur guerrier fut très effrayé et regarda s'il rougissait ou pâlissait. S'il pâlit, alors dans une situation stressante, le sang s'écoule de la tête du demandeur et il est sujet à une réaction passive. Par exemple, un évanouissement. Si le requérant rougissait, le sang lui montait à la tête. Ceux. il est enclin à des actions actives et à se précipiter dans les combats. Celui-ci a été jugé approprié.
Eh bien, une dernière chose. Pourquoi ai-je parlé de cette tâche à tout le monde au lieu de continuer à l'utiliser lors des entretiens ? C'est juste que les candidats potentiels ont déjà « appris » cette tâche et doivent en utiliser d'autres.
En fait, j'ai prêté attention à cet effet précisément en relation avec la tâche réelle de traitement d'image. La situation était quelque peu confuse et je n’ai pas tout de suite compris pourquoi mes fps avaient autant chuté après le refactoring. En général, tout le monde vit probablement beaucoup de moments aussi merveilleux.

Jusqu’à présent, la version dominante est que le cache du processeur est à blâmer. Ceux. l'accès séquentiel dans la première option fonctionne dans un hachage, qui est mis à jour lorsque vous dépassez une certaine limite. Lors de l'accès par colonnes, le hachage est obligé d'être constamment mis à jour et cela prend beaucoup de temps. Voyons cette version dans sa forme la plus pure. Créons un tableau et comparons ce qui est le plus rapide : traiter tous les éléments d'affilée ou traiter les éléments du tableau avec un nombre aléatoire le même nombre de fois ? Ce programme est ideone.com/tMaR2S. Pour 100 000 éléments de tableau, l’accès aléatoire est généralement nettement plus rapide. Qu'est-ce que cela signifie?
Ici, on m'a fait remarquer à juste titre (Big_Lebowski) que la réorganisation des boucles modifie les résultats en faveur de l'option séquentielle. Pour la pureté de l'expérience, j'ai dû mettre en place un cycle d'échauffement. En même temps, j'ai fait plusieurs répétitions pour obtenir la durée moyenne de fonctionnement comme le conseillait Leventov. Cela s'est avéré comme ceci ideone.com/yN1H4g. Ceux. L'accès aléatoire aux éléments d'un grand tableau est environ 10 % plus lent que l'accès séquentiel. Peut-être que le cache joue réellement un rôle. Cependant, dans la situation initiale, les performances ont considérablement chuté. Il y a donc autre chose.

Peu à peu, la version sur les actions supplémentaires lors du passage d'une ligne d'un tableau à une autre devient le leader. Et c'est vrai. Reste à savoir ce qui s’y passe exactement.

Balises :

• Programmation
• tableaux
• mémoire

Ajouter des balises

Un tableau est un outil puissant qui vous permet de travailler avec de grandes quantités de données. Évidemment, si vous devez stocker, par exemple, 100 valeurs quelque part pendant l'exécution de votre code, créer le même nombre de variables pour cela est pour le moins déraisonnable. Un tableau vous permet de stocker un grand nombre de valeurs sous un même nom et d'y accéder à l'aide de l'index approprié. Le concept de tableaux est la pierre angulaire de l’apprentissage de Java pour les débutants. Après tout, ils constituent la base de nombreuses structures de données.

Étant donné que Java est principalement de la POO, il présente une caractéristique distinctive par rapport aux tableaux d'autres langages de programmation : ils sont représentés sous forme d'objets. Entre autres avantages, cela élimine le besoin de surveiller le nettoyage de la mémoire, puisqu'elle est libérée automatiquement.

Création et manipulation de tableaux unidimensionnels

Un tableau unidimensionnel est un tableau classique et est une collection d'éléments associés à un nom commun, dont chacun correspond à un index spécifique. La méthode de déclaration d'un tableau est présentée dans la figure ci-dessous.

Tout d'abord, le type de tableau Java est déclaré, ce qui définit le type de valeurs qui y sont stockées. Il peut s'agir de n'importe quoi de valide. Ensuite vient le nom du tableau et les crochets indiquant au compilateur que cette variable est un tableau. Veuillez noter un fait important. peut être placé soit après le type de base du tableau, soit après le nom du tableau. Après le signe égal, est indiqué l'opérateur new, qui initie l'allocation de mémoire pour le tableau (le même que dans le cas des objets), le type d'éléments qui y seront stockés (doit être compatible avec le type de base déclaré plus tôt), et enfin leur numéro, indiqué entre crochets.

La numérotation des éléments dans un tableau Java commence à 0. Ainsi, l'index du premier élément de ce tableau sera 0 et le sixième - 5. Pour faire référence à un élément spécifique du tableau, par exemple le cinquième, il suffit indiquez le nom du tableau et l'index de l'élément entre crochets à côté du nom. De cette façon, vous pouvez à la fois attribuer une valeur à un élément et la récupérer. Cependant, vous devez être prudent car si vous passez un index pour lequel l'élément n'existe pas, une erreur se produira.

Tableaux multidimensionnels en Java

Les tableaux multidimensionnels sont des lignes de tableaux unidimensionnels référencés par des éléments d'autres tableaux. En d’autres termes, les plus simples d’entre eux sont bidimensionnels. À l’aide de leur exemple, nous essaierons de comprendre le concept. Pour plus de clarté, la figure ci-dessous montre la syntaxe et le diagramme décrivant la structure d'un tableau bidimensionnel.

Comme vous pouvez le constater, la syntaxe n’est pas très différente de celle des tableaux unidimensionnels. Regardons la structure. Dans les premières parenthèses, nous avons réservé un espace pour 5 éléments. Ces éléments ne sont rien de plus que des références à des tableaux individuels. De plus, la taille de chacun d'eux est déterminée par le nombre entre les deuxièmes parenthèses. En fait, l’analogue des tableaux bidimensionnels en mathématiques sont les matrices. Veuillez noter qu'en plus des éléments, un emplacement distinct est alloué en mémoire où la valeur de longueur du tableau (longueur) est stockée. En règle générale, le travail avec des tableaux multidimensionnels s'effectue à l'aide de boucles for imbriquées.

Tableaux irréguliers

Un tableau bidimensionnel est un tableau de tableaux. Nous l'avons déjà découvert. Mais les tableaux qu’il contient peuvent-ils avoir des longueurs différentes ? La réponse est oui, ils le peuvent. Pour ce faire, Java offre la possibilité de déclarer un tableau à deux dimensions d'une manière particulière. Par exemple, nous souhaitons créer un tableau bidimensionnel qui stockerait trois tableaux unidimensionnels de longueur 2, 3 et 4, respectivement. Il est déclaré ainsi :

intar = nouvelint;

Veuillez noter que nous n'avons pas inclus de numéro dans les deuxièmes parenthèses. La détermination de la taille des tableaux dans arr se fait comme ceci :

En accédant à l'élément d'index 0, qui pointe vers le premier tableau, on le déclare de dimension 2. L'élément d'index 1 stockera un tableau de dimension 3, et ainsi de suite. C'est assez simple.

Syntaxe alternative de déclaration de tableau Java

Vous pouvez également initialiser les tableaux directement lors de leur création. C'est assez simple.

Faites attention à la déclaration des tableaux jerseyNumber et playerName.

Dans le cas de tableaux à deux dimensions, cette déclaration ressemble à ceci :

Pour ce faire, à la place de l'opérateur new, des accolades sont ouvertes, dans lesquelles tous les éléments sont répertoriés, séparés par des virgules. Java dans ce cas leur alloue automatiquement de la mémoire et les indexe en conséquence.

Tableaux de classe d'assistance

Pour travailler avec des entités telles que des tableaux en Java, le package java.util possède une classe spéciale appelée Arrays, qui fournit de nombreuses méthodes statiques qui facilitent grandement leur utilisation. La liste des principales méthodes est présentée dans la figure ci-dessous.

Examinons quelques-unes des méthodes de tableau Java les plus utiles :

CopyOf (array, length) - renvoie une copie du tableau transmis de la longueur correspondante. Si la longueur transmise est supérieure au tableau d'origine, alors tous les éléments « supplémentaires » sont remplis avec une valeur par défaut (0 s'il s'agit d'un type simple et null s'il s'agit d'un type référence).

CopyOfRange(array, first index, last index) - non affiché dans l'image, mais une méthode utile. Il copie la partie du tableau transmis, définie par les indices correspondants, en commençant par le premier et en terminant par le dernier.

Trier (tableau) - trie les éléments du tableau par ordre croissant.

Fill (array, value) - Remplit le tableau transmis avec la valeur appropriée.

BinarySearch (tableau, valeur) - renvoie l'index auquel se trouve l'élément avec la valeur correspondante dans le tableau trié transmis. S'il n'existe aucun élément de ce type, un nombre négatif est renvoyé.

Les méthodes étant statiques, leur appel ne nécessite pas de créer une instance de la classe Arrays. Ils sont appelés directement depuis celui-ci : Arrays.sort(arr).

Conclusion

Nous avons couvert les aspects les plus importants concernant les tableaux, et pour ceux qui commencent tout juste à apprendre Java pour débutants, cela suffira pour une compréhension de base d'une entité telle qu'un tableau et les techniques de base pour travailler avec elle. Bien entendu, la pratique vous permettra de mieux comprendre le fonctionnement de cet outil. Prenez donc le temps de faire quelques exercices en manipulant les tableaux de différentes manières.

La classe auxiliaire Array Java est déjà utilisée dans des conditions de « combat », il est donc d'abord recommandé d'apprendre à effectuer manuellement toutes les opérations de base avec les tableaux.

1. Que sont les tableaux ?

Il s'agit d'une structure spéciale qui existe dans presque tous les langages de programmation, permettant de décrire un groupe d'objets du même type à l'aide d'un nom commun.

Imaginons que vous ayez un refuge pour animaux sans abri avec cinq chats. Vous ne vous souvenez pas du nom de chacun, mais tout le monde a une médaille avec un numéro qui permet d’identifier chaque animal. On peut dire qu'il s'agit d'un tableau de chats de taille cinq. Veuillez noter que l'indexation commence à zéro - c'est habituel en Java. S'il n'était pas possible de créer des tableaux, il faudrait déclarer cinq variables et leur donner des noms, ce qui n'est pas très pratique.

En Java, vous pouvez créer des tableaux de n'importe quelle taille : unidimensionnelle, bidimensionnelle, tridimensionnelle, etc. Commençons par l'option la plus simple : les tableaux unidimensionnels.

2. Tableaux unidimensionnels

Les tableaux unidimensionnels sont une liste de variables du même type. Pour créer un tableau, vous devez d'abord déclarer une variable tableau du type requis. La forme générale de déclaration d’un tableau unidimensionnel est la suivante :

TypeVariableName ;

où est le paramètre taper désigne le type d'un élément du tableau, également appelé type de base.

Exemple 1. Exemple de déclaration de tableaux

Les crochets peuvent être placés avant ou après une variable. Mais une option plus correcte consiste à indiquer des parenthèses avant la variable - de cette façon le type et les parenthèses sont au même endroit, ce qui permet de comprendre au premier coup d'œil qu'il s'agit d'un tableau de ce type.

Int moisJours ; double moisSalaire ;

2.1. Initialisation d'un tableau à l'aide d'un mot-clé nouveau

Lorsqu'un tableau est déclaré, la mémoire ne lui a pas encore été allouée. Pour allouer de la mémoire à un tableau, utilisez le mot-clé nouveau, après quoi le type du tableau est à nouveau indiqué et la taille entre crochets :

NomVariable = nouveau type[taille] ;

Un tableau peut être déclaré et initialisé avec une seule ligne :

Valeurs Int = nouveau int ;

Exemple 2. Exemple de déclaration de tableau

Regardons un exemple de déclaration d'un tableau de type int taille 12 dans cet exemple. Après avoir exécuté la ligne int moisJours = nouveau int un tableau de 12 éléments a été créé. Chaque élément se voit attribuer une valeur par défaut pour le type donné. Pour le type int c'est zéro. Pour accéder à un élément individuel d'un tableau, après le nom du tableau, nous spécifions l'index de l'élément entre crochets. De cette façon, nous pouvons accéder à un élément du tableau pour modifier ou obtenir sa valeur.

Classe publique Array1 ( public static void main(String args) ( int MonthDays = new int; MonthDays = 31; MonthDays = 28; MonthDays = 31; MonthDays = 30; MonthDays = 31; MonthDays = 30; MonthDays = 31; MonthDays = 31 ; moisJours = 30; moisJours = 30; moisJours = 31; System.out.println("En avril " + moisJours + " jours.");

2.2. Initialisation d'un tableau à l'aide d'un bloc d'initialisation

Exemple 3. Exemple d'initialisation d'un tableau unidimensionnel

Si vous connaissez à l'avance les valeurs de chaque élément du tableau, vous pouvez utiliser un bloc pour initialiser le tableau. Au lieu de nouveau int, Les valeurs des éléments du tableau sont répertoriées entre accolades, séparées par des virgules. La taille du tableau est déduite par le compilateur à partir du nombre d'éléments spécifiés.

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

2.3. Tableau sans nom

Il existe également une troisième forme de déclaration d'un tableau : un tableau sans nom. Il peut être utilisé dans deux cas. Tout d'abord, vous avez déclaré et initialisé le tableau scores de test taille quatre , mais ensuite, pour une raison quelconque, il doit être modifié – il doit contenir trois éléments. Vous ne pouvez pas réutiliser le formulaire pour initialiser un tableau - il y aura une erreur de compilation :

Int testScores = (1, 2, 3, 4); ... testScores = (4, 7, 2); //erreur de compilation

Mais vous pouvez utiliser un tableau sans nom, ce qui créera un nouveau tableau en mémoire. La forme d'écriture d'un tableau sans nom est un mélange des deux premiers :

TestScores = nouveau int(4, 7, 2);

La deuxième utilisation d'un tableau sans nom consiste à transmettre le tableau à une méthode. Dans l'exemple suivant, la méthode imprimer prend en entrée un tableau de type int. Lorsque vous appelez une méthode, vous pouvez passer un tableau sans nom comme argument.

Exemple 4. Un exemple de tableau sans nom

public class Array3 ( public static void main(String args) ( int testScores = (1, 2, 3, 4); for (int element: testScores) ( System.out.print(element + " "); ) System.out .println(); testScores = new int(4, 7, 2); pour (élément int : testScores) ( System.out.print(element + " "); ) System.out.println(); , 2, 3)); public static void print(int array) ( for (int element: array) ( System.out.print(element + " "); ) ) )

3. Tableaux multidimensionnels

Les tableaux multidimensionnels sont des tableaux de tableaux.

Lors de la déclaration d'une variable de tableau multidimensionnel, une ligne distincte de crochets est utilisée pour indiquer chaque index supplémentaire. Par exemple:

Int deuxD = nouveau int ;

La figure suivante montre comment représenter visuellement un tableau bidimensionnel de 4 x 5. L'index de gauche définit la ligne et la colonne de droite.

Exemple 5 : exemple de tableau bidimensionnel

L'exemple suivant montre comment définir des valeurs dans un tableau bidimensionnel 4x5. Une boucle externe est utilisée pour parcourir les chaînes pour, pour parcourir les colonnes - interne. Chaque élément suivant se voit attribuer une valeur supérieure à la précédente.

Classe publique TwoDArray1 ( public static void main(String args) ( int twoD = new int; int i, j, k = 0; for (i = 0; i< 4; i++) { for (j = 0; j < 5; j++) { twoD[i][j] = k++; System.out.print(twoD[i][j] + " "); } System.out.println(); } } }

3.2. Représentation d'un tableau multidimensionnel en mémoire

Voyons maintenant comment le tableau est représenté int deuxD = nouveau int; en mémoire. deuxD ne pointe pas vers une matrice, mais vers une ligne (rouge) composée de trois éléments. La valeur de chaque élément est une référence à une chaîne de quatre éléments (de couleur violette).

L'image suivante montre comment un tableau tridimensionnel est stocké int threeD = nouvel int en mémoire :

Un tableau de n’importe quelle taille peut ainsi être stocké en mémoire.

Dans les tableaux bidimensionnels que nous avons examinés jusqu'à présent, le nombre d'éléments dans chaque ligne est le même - c'est le plus souvent le cas. Mais ce n’est pas nécessaire ; chaque ligne peut contenir un nombre différent d’éléments. Par exemple:

Exemple 6. Exemple de tableau bidimensionnel avec différentes dimensions

Regardons le code qui implémente un tel tableau. Lors de la déclaration d'un tableau, vous devez spécifier le nombre d'éléments uniquement pour la première dimension - tableau int = nouveau int. Ainsi, nous indiquons le nombre de lignes dans le tableau, mais nous n'allouons pas de mémoire pour chaque ligne. Ensuite, nous allouons une mémoire distincte pour chaque ligne du tableau. Par exemple, une ligne avec l'index zéro sera de taille 1 - tableau = nouveau int.

Classe publique TwoDArray2 ( public static void main(String args) ( int array = new int; array = new int; array = new int; array = new int; array = new int; int i, j, k = 0; for ( je = 0 ;< 4; i++) { for (j = 0; j < i + 1; j++) { array[i][j] = k++; System.out.print(array[i][j] + " "); } System.out.println(); } } }

3.4. Bloc pour initialiser un tableau multidimensionnel

Exemple 7 : Initialisation d'un tableau à deux dimensions

Pour les tableaux multidimensionnels, vous pouvez également utiliser un bloc pour l'initialisation si les valeurs de tous les éléments sont connues à l'avance. Chaque ligne individuelle est entourée d'accolades :

Classe publique TwoDArray3 ( public static void main(String args) ( double arrayTwoD = ( (0, 1, 2, 3), (4, 5, 6, 7), (8, 9, 10, 11), (12, 13, 14, 15) ); for (double arrayOneD: arrayTwoD) ( for (double element: arrayOneD) ( System.out.print(element + " "); ) System.out.println(); ) ) )

3.4. Longueur du tableau

Exemple 8 : Obtenir la longueur d'un tableau

L'exemple suivant montre comment obtenir la longueur d'un tableau. A cet effet, la variable est utilisée longueur. Avec un tableau unidimensionnel, tout est clair : sa longueur est le nombre de ses éléments. La longueur d'un tableau multidimensionnel correspond au nombre d'éléments de sa première dimension. Par exemple, la longueur du tableau tableau2 vaut 2. Vous pouvez également obtenir la longueur de chaque ligne du tableau. Par exemple, tableau2.longueur- renverra le nombre d'éléments dans la ligne d'index zéro.

Classe publique ArraySize ( public static void main(String args) ( int array1 = (1, 2, 3, 4); int array2 = ((1, 1, 1), (2, 2, 2)); System.out .println("Taille du tableau1 = " + array1.length); System.out.println("Taille du tableau2 = " + array2.length System.out.println("Taille du tableau à 1 ligne array2 = " +); tableau2 .longueur);

Résultat de l'exécution :

Taille du tableau tableau1 = 4 Taille du tableau tableau2 = 2 Taille du tableau tableau 1 ligne2 = 3

4. Techniques utiles lorsque vous travaillez avec des tableaux

Il existe un certain nombre de méthodes utiles lorsque vous travaillez avec des tableaux. Regardons-les :

4.1. Méthode Tableaux.toString()

La méthode renvoie une représentation sous forme de chaîne d'un tableau unidimensionnel, séparée par des virgules. Au lieu de parcourir des tableaux pour, comme nous l'avons fait dans l'exemple 4, vous pouvez utiliser cette méthode pour afficher des éléments sur la console :

Exemple 9. Application de la méthode Tableaux.toString()

importer java.util.Arrays ; classe publique ArraysToStringDemo ( public static void main(String args) ( int array = (1, 4, 6, 3, 8); System.out.println(Arrays.toString(array)); ) )

4.2. Méthode Arrays.deepToString()

La méthode renvoie une représentation sous forme de chaîne d'un tableau multidimensionnel, en mettant en évidence les lignes entre crochets :

Exemple 10. Application de la méthode Arrays.deepToString()

importer java.util.Arrays ; public class ArraysDeepToStringDemo ( public static void main(String args) ( String array = (("un-un", "un-deux", "un-trois"), ("deux-un", "deux-deux", "deux-trois")); System.out.println(Arrays.deepToString(array) ) )

4.3. Méthode Tableaux.sort()

Méthode Tableaux.sort() trie les éléments d'un tableau numérique par ordre croissant :

Exemple 11. Trier un tableau

importer java.util.Arrays ; classe publique ArraysSort1 ( public static void main(String args) ( int array = new int(3, 1, 5, 6, 8); Arrays.sort(array); System.out.println(Arrays.toString(array)) ; ) )

4.4. Méthode Tableaux.binarySearch()

Méthode Tableaux.binarySearch() recherche dans un tableau une valeur donnée et renvoie le numéro de l'élément. Si l'élément recherché n'est pas trouvé, il renvoie -(poste + 1), Où position- la position de l'élément où il POURRAIT ÊTRE. Le tableau doit être trié, sinon le résultat de l'appel de méthode sera indéfini :

Exemple 12 : Recherche d'un élément de tableau

importer java.util.Arrays ; classe publique BinarySearch1 ( public static void main(String args) ( int array1 = (10, 20, 30, 40); int pos1 = Arrays.binarySearch(array1, 20); int pos2 = Arrays.binarySearch(array1, 25); System.out.println(pos1); System.out.println(pos2) )

Résultat de l'exécution :

4.5. Méthode Système.arraycopy()

Méthode Système.arraycopy() vous permet de copier une partie d'un tableau vers un autre tableau.

Exemple 13 : Copie d'un tableau

Regardons un exemple qui copie les éléments 2,3,4 d'un tableau tableauSource mettre en réseau tableauDestination :

Importer java.util.Arrays ; classe publique ArrayCopy1 ( public static void main(String args) ( int arraySource = (1, 2, 3, 4, 5, 6); int arrayDestination = (0, 0, 0, 0, 0, 0, 0, 0) System.out.println("arraySource: " + Arrays.toString(arraySource)); System.out.println("arrayDestination: " + Arrays.toString(arrayDestination) , 3); arrayDestination après arrayCopy : " + Arrays.toString(arrayDestination) ) )

Résultat de l'exécution :

ArraySource : arrayDestination : arrayDestination après arrayCopy :

Exemple 14. Copie d'un tableau de lui-même vers lui-même

Vous pouvez copier dans le même tableau avec des zones qui se chevauchent :

Importer java.util.Arrays ; classe publique ArrayCopy2 ( public static void main(String args) ( int array = (1, 2, 3, 4, 5, 6, 7, 8); System.out.println(Arrays.toString(array)); System. arraycopy (tableau, 1, tableau, 3, 3); System.out.println (Arrays.toString (tableau) )

Résultat de l'exécution :

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.

Un tableau est un ensemble 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 du 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.

Une combinaison entre déclarer une variable de type tableau et allouer de la mémoire au tableau directement dans la déclaration est possible :
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;< 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 à deux dimensions nommée twoD :
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 d'égale longueur (matrices), et effectue le produit d'une matrice par une autre :

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: "); // copie du tableau mas1 vers mas2 System.arraycopy(mas1, 0, mas2, 2, 3); * 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: "); 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é.