Werken met datastructuren in Java

Op een bepaald punt in onze ontwikkeling als softwaremakers zullen we situaties tegenkomen waarin we veel complexere dingen moeten doen binnen onze programma's, over het algemeen vertaalt dit zich in complexer gegevensbeheer en een andere organisatie ervan.
Data structuurHiervoor hebben we de Data structuren, waarmee we onze informatie binnen het programma kunnen ordenen om ze op een ordelijke en schematische manier te kunnen openen. In Java We kunnen verschillende soorten structuren aan dankzij de klassen en standaardbibliotheken, dus als we leren welke we beschikbaar hebben, is het mogelijk dat we het nodige voordeel kunnen halen en zo onze doelen kunnen bereiken.
EEN reeks is een type structuur met een lineaire conformatie en kan een hoeveelheid gegevens van hetzelfde type opslaan. De gegevens die u kunt opslaan zijn primitieve typen zoals: int, bool, enz. Maar je kunt ook soorten objecten opslaan, hoewel het in dit geval de verwijzing naar het object is en niet het object als zodanig, maar het is iets heel handigs om te weten.
ToegangOmdat het lineair is, moet de toegang tot de inhoud opeenvolgend worden gedaan, hoewel we rechtstreeks naar een index ervan kunnen verwijzen en de inhoud ervan kunnen verkrijgen, reageert de route die we in de meeste gevallen op deze structuur kunnen doen op een reeks van uw indexen.
Als we een index per element hebben, is het een array of eendimensionale vectorAan de andere kant, als we meer dan één index per element hebben, hebben we het over arrays multidimensionaal, dat wil zeggen, binnen een index hebben we een interne structuur met zijn eigen indexen.
Het declareren van een array is heel eenvoudig, we hoeven alleen het type gegevens te definiëren dat het gaat opslaan en de afmetingen met haakjes aan te geven, dan moeten we de naam ervan definiëren en daarmee kunnen we het gaan gebruiken.
Hoewel er verschillende manieren zijn om een ​​array te declareren, heeft de voorkeur de korte vorm zoals we hieronder zien:

type [] nameArrary = nieuw type [lengte];

In het geval van een array multidimensionaal we kunnen hetzelfde doen, maar de nieuwe lagen of dimensies toevoegen binnen dezelfde declaratie, bijvoorbeeld:
Tweedimensionale matrix:

type [] [] nameArrary = nieuw type [lengte] [lengte];

Driedimensionale matrix:

type [] [] [] nameArrary = nieuw type [lengte] [lengte] [lengte];

Het enige waar we rekening mee moeten houden is dat de dingen na drie dimensies veel complexer worden, maar dit zal worden bepaald door onze behoeften op het moment van de ontwikkeling van het programma.
Om door een array te gaan, moeten we een van de iteratieve cycli gebruiken die we beschikbaar hebben, de cyclus is voor een van de favorieten, omdat we de grootte van de array kunnen aangeven en elk van zijn elementen kunnen doorlopen.
We moeten in gedachten houden dat de indices van de arrays vanaf nul beginnen, dus in een array met drie elementen zouden hun indices zijn [0], [1], [2], Hiermee moet rekening worden gehouden, aangezien het geen traditioneel account is, het tot verwarring kan leiden.
Een algemeen voorbeeld van het doorlopen van een array is zoiets als het volgende:

 voor (int i = 0; i

Op dezelfde manier dat we in dat kleine voorbeeld een zeefdruk hebben gemaakt van de inhoud van de bijbehorende index, kunnen we ook opeenvolgende toewijzingen en andere bewerkingen met de array uitvoeren. In het geval van een multidimensionale array moeten we een cyclus doen voor elk van de dimensies die we hebben, daarom spreken we dat na meer dan drie dimensies een array erg complex wordt.
We gaan een kleine code bouwen waarin we een array gaan definiëren, dan gaan we een rondleiding maken langs de elementen en we gaan ze op het scherm laten zien. Dus laten we eens kijken hoe onze code eruit ziet:

 public class VoorbeeldArray1 {public static void main (String [] argv) {int [] ourArray = new int [12]; for (int i = 0; i <12; i ++) {ourArray [i] = i + 1; System.out.println ("De inhoud van de array in: [" + i + "] is:" + ourArray [i]); } System.out.println ("De totale lengte van de array is:" + ourArray.length); }} 

In dit programma is het eerste wat we doen na het definiëren van onze klasse en de methode voornaamst is het definiëren van een array van het type genaamd int onze Array waaraan we een lengte van 12 elementen toewijzen, dan met een for-lus die van 0 tot 11 gaat, gaan we een waarde toewijzen aan elk van de indexen van de array, dan doen we het onmiddellijk, we printen de waarde en tenslotte gebruiken we het eigendom lengte van de array waarmee we de totale lengte kunnen verkrijgen en we drukken deze gelijk af.
Als we dit in onze console zien bij het uitvoeren van het programma, krijgen we het volgende:

VERGROTEN

Zoals we kunnen zien, krijgen we een regel voor elk element van de array en een laatste regel die de werkelijke grootte aangeeft, we merken ook op dat als we van 0 tot 11 tellen, we 12 elementen hebben, dus wat we uitleggen over de indextelling is gedemonstreerd van de array.
Het gebruik van arrays is erg populair en erg handig, maar er zijn momenten waarop de beperkingen beginnen te worden gezien, vooral wanneer we werken met zeer dynamische structuren waarvan we niet weten hoeveel elementen we aan het einde zullen hebben en waar we een weinig meer functionaliteit, afgezien van iteraties om de elementen te doorlopen.
Wanneer we onszelf in de noodzaak zien om complexer te zijn in het omgaan met gegevens, kunnen we naar de collecties, die niets meer zijn dan een aantal klassen gegroepeerd in de standaardbibliotheek van Java java.util en die ons in staat stellen om andere soorten datastructuren te creëren.
In dit geval gaan we de klas een beetje verkennen ArrayLijst, waarmee we lijsten met arrays kunnen maken zoals de naam aangeeft, maar om de elementen ervan te manipuleren, moeten we dit op verschillende manieren doen.
Laten we hieronder een kleine lijst bekijken van de beschikbare methoden van de klasse ArrayLijst belangrijker is en dat we misschien onze programma's moeten maken, als we iets extra's nodig hebben, kunnen we altijd onze toevlucht nemen tot de officiële documentatie van de taal.
toevoegen ()Met deze methode kunnen we een element aan het einde of op een bepaalde positie aan de lijst toevoegen, dit wordt gedefinieerd door de parameters door te geven.
Doorzichtig ()Reinigt de structuur door alle elementen die het bevat te verwijderen of leeg te maken.
krijgen ()Het retourneert de waarde van de aangegeven index van de lijst in kwestie.
verwijderen ()Met deze methode kunnen we een bepaald element uit de datastructuur verwijderen.
naarArray ()Met deze methode kunnen we een array-conversie maken van de inhoud van de lijst of datastructuur.
Een lijst declareren met ArrayLijst, we moeten gewoon een instantie van deze klasse maken, hiermee kunnen we gaan werken aan de toewijzing van elementen en inhoud, hiervoor kunnen we de volgende syntaxis zien:

ArrayList ourList = nieuwe ArrayList ();

Hoewel we ook een verklaring en gelijktijdige toewijzing van elementen kunnen gebruiken, zoals we in de volgende coderegel zien:

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

De rondleiding door onze lijst kan worden bereikt met een iteratieve cyclus met voor () die we al in de arrays zagen, het verschil is dat, aangezien we het aantal elementen in onze lijsten niet zeker weten, we de limiet moeten definiëren met behulp van de methode maat () van hetzelfde en om de inhoud in een bepaalde index te verkrijgen, gebruiken we de methode krijgen (). Een voorbeeld van de syntaxis voor deze walkthrough zou het volgende kunnen zijn:

 voor (int i = 0; i

Nu gaan we een klein programma maken waarin we in de praktijk brengen wat we hebben gezien over ArrayLijst en specificeer op deze manier een leerproces over de gegevensstructuur:

 java.util.ArrayList importeren; public class VoorbeeldList1 {public static void main (String [] argv) {ArrayList ourList = new ArrayList (); onzeLijst.add ("Peter"); onzeLijst.add ("Jan"); ourList.add ("Francisco"); ourList.add ("Manolo"); onzeLijst.add ("Paul"); voor (int i = 0; i

In deze code zien we dat het eerste wat we doen is de klasse importeren ArrayLijst van het pakket java.util, als we dat niet doen, kunnen we het niet gebruiken.
Vervolgens hebben we een nieuwe lijst met type-elementen gedefinieerd Draad, dan zullen we de lijst populair maken met behulp van de methode toevoegen ()Zoals we kunnen zien, hebben we geen elementlimiet gedefinieerd, deze lijst zal dynamisch groeien naarmate we er elementen aan toevoegen.
Eindelijk met een cyclus voor () en met behulp van de methode maat () van ons lijstobject doorlopen we de elementen ervan en om de waarde van elke positie te verkrijgen gebruiken we de methode krijgen () hiermee kunnen we dan de inhoud printen. Laten we eens kijken hoe het eruit ziet wanneer we het op onze console uitvoeren:

VERGROTEN

Hiermee hebben we deze tutorial afgerond, we hebben al geleerd om de datastructuren binnen te maken en ermee te werken Java, zullen we hierdoor complexere applicaties en programma's kunnen bouwen die aan onze behoeften voldoen.