Travailler avec des structures de données en Java

À un moment donné de notre développement en tant que créateurs de logiciels, nous allons nous heurter à des situations dans lesquelles nous devons faire des choses beaucoup plus complexes dans nos programmes, ce qui se traduit généralement par une gestion des données plus complexe et une organisation différente de celles-ci.
Structure de donnéesPour cela nous avons le Structures de données, qui nous permettent d'organiser nos informations au sein du programme pour pouvoir y accéder de manière ordonnée et schématique. Dans Java Nous pouvons gérer différents types de structures grâce à ses classes et bibliothèques standard, donc si nous apprenons celles dont nous disposons, il est possible que nous puissions en tirer l'avantage nécessaire et ainsi atteindre nos objectifs.
UNE déployer est un type de structure qui a une conformation linéaire et peut stocker une quantité de données du même type. Les données que vous pouvez stocker sont des types primitifs tels que entier, booléen, etc.. Mais vous pouvez également stocker des types d'objets, bien que dans ce cas, il soit stocké la référence à l'objet et non à l'objet en tant que tel, cependant c'est quelque chose de très utile à savoir.
AccéderEtant linéaire, l'accès à son contenu doit se faire de manière séquentielle, bien que l'on puisse pointer directement sur un index de celui-ci et obtenir son contenu, le cheminement dans la plupart des cas que l'on peut faire sur cette structure répond à une séquence de vos index.
Quand on a un index par élément c'est un tableau ou vecteur unidimensionnelPar contre, quand on a plus d'un index par élément on parle de tableaux multidimensionnel, c'est-à-dire qu'à l'intérieur d'un index, nous avons une structure interne avec ses propres index.
Déclarer un tableau est très simple, il suffit de définir le type de données qu'il va stocker et d'indiquer les dimensions entre parenthèses, puis il faut définir son nom et avec cela on peut commencer à l'utiliser.
Bien qu'il existe plusieurs manières de déclarer un tableau, la préférée est la forme courte comme nous le voyons ci-dessous :

type [] nameArrary = nouveau type [longueur];

Dans le cas d'un tableau multidimensionnel nous pouvons faire la même chose mais en ajoutant les nouvelles couches ou dimensions au sein de la même déclaration, par exemple :
Tableau à deux dimensions :

type [] [] nameArrary = nouveau type [longueur] [longueur];

Tableau en trois dimensions :

type [] [] [] nameArrary = nouveau type [longueur] [longueur] [longueur] ;

La seule chose que nous devons garder à l'esprit est qu'après trois dimensions les choses deviennent beaucoup plus complexes, mais cela sera dicté par nos besoins au moment de l'élaboration du programme.
Pour parcourir un tableau, nous devons utiliser l'un des cycles itératifs dont nous disposons, le cycle étant pour l'un des favoris, puisque nous pouvons indiquer la taille du tableau et parcourir chacun de ses éléments.
Nous devons garder à l'esprit que les indices des tableaux commencent à zéro, donc dans un tableau à trois éléments, leurs indices seraient [0], [1], [2], Ceci doit être pris en compte puisqu'il ne s'agit pas d'un compte traditionnel, cela peut prêter à confusion.
Un exemple générique de la façon de parcourir un tableau est quelque chose comme le suivant :

 pour (int i = 0; i

De la même manière que dans ce petit exemple nous avons fait une sérigraphie du contenu de l'index correspondant, nous pouvons également faire des affectations séquentielles et d'autres opérations avec le tableau. Dans le cas d'un tableau multidimensionnel, il faut faire un cycle pour chacune des dimensions que l'on a, c'est pourquoi on dit qu'après plus de trois dimensions un tableau devient très complexe.
On va construire un petit code dans lequel on va définir un tableau, puis on va faire le tour de ses éléments et on va les montrer à l'écran. Voyons donc à quoi ressemble notre code :

 public class ExampleArray1 {public static void main (String [] argv) {int [] ourArray = new int [12]; for (int i = 0; i <12; i ++) {notreTableau [i] = i + 1; System.out.println ("Le contenu du tableau dans : [" + i + "] est :" + notreArray [i]); } System.out.println ("La longueur totale du tableau est :" + notreArray.length); }} 

Dans ce programme, la première chose que nous faisons après avoir défini notre classe et la méthode principale est de définir un tableau de type nommé int notre tableau auquel on assigne une longueur de 12 éléments, puis avec une boucle for qui va de 0 à 11 on va assigner une valeur à chacun des index du tableau, puis on le fait tout de suite on imprime sa valeur et enfin on utilise la propriété longueur du tableau qui nous permet d'obtenir sa longueur totale et nous l'imprimons également.
Si nous voyons cela dans notre console lors de l'exécution du programme, nous obtiendrons ce qui suit :

AGRANDIR

Comme nous pouvons le voir, nous obtenons une ligne pour chaque élément du tableau et une ligne finale qui indique sa taille réelle, nous notons également que si nous comptons de 0 à 11, nous avons 12 éléments, donc ce que nous expliquons sur le nombre d'indices est démontré du tableau.
L'utilisation de tableaux est très populaire et très utile, cependant il y a des moments où ses limites commencent à être vues, surtout lorsque nous travaillons avec des structures très dynamiques où nous ne savons pas combien d'éléments nous aurons à la fin et où nous avons besoin d'un peu plus de fonctionnalités en dehors des itérations pour parcourir ses éléments.
Quand on se voit dans le besoin d'être plus complexe dans le traitement des données, on peut aller au collections, qui ne sont rien de plus qu'un certain nombre de classes regroupées dans la bibliothèque standard de Java java.util et qui nous permettent de créer d'autres types de structures de données.
Dans ce cas, nous allons explorer un peu la classe Liste des tableaux, qui nous permet de créer des listes de tableaux comme son nom l'indique, mais pour manipuler ses éléments nous devons le faire via ses différentes méthodes.
Voyons ci-dessous une petite liste des méthodes disponibles de la classe Liste des tableaux plus important et que nous pouvons avoir besoin de créer nos programmes, si nous avons besoin de quelque chose de plus, nous pouvons toujours recourir à la documentation officielle de la langue.
ajouter ()Cette méthode permet d'ajouter un élément à la liste soit à la fin soit à une certaine position, celle-ci est définie en passant les paramètres.
dégager ()Nettoie la structure en supprimant ou en vidant tous les éléments qu'elle contient.
avoir ()Il retourne la valeur de l'index indiqué de la liste en question.
supprimer ()Cette méthode nous permet de supprimer un élément particulier de la structure de données.
toArray ()Cette méthode nous permet de faire une conversion de tableau du contenu de la liste ou de la structure de données.
Pour déclarer une liste avec Liste des tableaux, nous devons simplement créer une instance de cette classe, avec cela nous pouvons commencer à travailler sur l'affectation des éléments et du contenu, pour cela nous pouvons voir la syntaxe suivante :

ArrayList ourList = new ArrayList ();

Bien que nous puissions également utiliser une déclaration et une affectation simultanée d'éléments comme nous le voyons dans la ligne de code suivante :

List ourList = Arrays.asList ("Pedro", "Juan", "Manuel");

Le tour de notre liste peut être réalisé avec un cycle itératif avec pour () que nous avons déjà vu dans les tableaux, la différence est que puisque nous ne connaissons pas avec certitude le nombre d'éléments dans nos listes, nous devons définir la limite à l'aide de la méthode Taille () du même et pour obtenir le contenu d'un certain index, nous utilisons la méthode avoir (). Un exemple de syntaxe pour cette procédure pas à pas pourrait être le suivant :

 pour (int i = 0; i

Maintenant, nous allons créer un petit programme où nous mettons en pratique ce que nous avons vu à propos de Liste des tableaux et ainsi spécifier un apprentissage sur ladite structure de données :

 importer java.util.ArrayList; public class ExampleList1 {public static void main (String [] argv) {ArrayList ourList = new ArrayList (); ourList.add ("Pierre"); ourList.add ("Jean"); ourList.add ("Francisco"); ourList.add ("Manolo"); ourList.add ("Paul"); pour (int i = 0; i

Dans ce code, nous voyons que la première chose que nous faisons est d'importer la classe Liste des tableaux du paquet java.util, si nous ne le faisons pas, nous ne pourrons pas l'utiliser.
Ensuite, nous avons défini une nouvelle liste d'éléments de type Chaîne de caractères, alors nous allons vulgariser la liste en utilisant la méthode ajouter ()Comme nous pouvons le voir, nous n'avons pas défini de limite d'éléments, cette liste s'allongera dynamiquement au fur et à mesure que nous y ajouterons des éléments.
Enfin avec un cycle pour () et en utilisant la méthode Taille () de notre objet liste nous parcourons ses éléments et pour obtenir la valeur de chaque position nous utilisons la méthode avoir () avec cela, nous pouvons ensuite imprimer le contenu. Voyons à quoi cela ressemble lorsque nous l'exécutons sur notre console :

AGRANDIR

Avec cela, nous avons terminé ce didacticiel, nous avons déjà appris à créer et à travailler avec les structures de données dans Java, cela nous permettra de créer des applications et des programmes plus complexes qui répondent à nos besoins.