Innehållsförteckning
Vid något tillfälle i vår utveckling som mjukvaruutvecklare kommer vi att stöta på situationer där vi måste göra mycket mer komplexa saker inom våra program, vanligtvis leder detta till mer komplex datahantering och en annan organisation av dem.DatastrukturFör detta har vi Data struktur, som gör att vi kan organisera vår information inom programmet för att kunna komma åt dem på ett ordnat och schematiskt sätt. I Java Vi kan hantera olika typer av strukturer tack vare dess klasser och standardbibliotek, så om vi lär oss vilka vi har tillgängliga är det möjligt att vi kan dra den nödvändiga fördelen och därmed uppfylla våra mål.
A array är en typ av struktur som har en linjär konformation och kan lagra en mängd data som är av samma typ. Den data du kan lagra är primitiva typer som t.ex. int, bool, etc.. Men du kan också lagra typer av objekt, även om det i detta fall lagras är referensen till objektet och inte objektet som sådant, men det är något mycket användbart att veta.
TillgångEftersom det är linjärt måste åtkomsten till dess innehåll göras sekventiellt, även om vi kan peka direkt på ett index för det och få dess innehåll, svarar rutten i de flesta fall som vi kan göra på denna struktur på en sekvens av dina index.
När vi har ett index per element är det en array eller endimensionell vektorÅ andra sidan, när vi har mer än ett index per element talar vi om matriser flerdimensionell, det vill säga, inom ett index har vi en intern struktur med egna index.
Att förklara en matris är väldigt enkelt, vi behöver bara definiera vilken typ av data den ska lagra och ange måtten med parenteser, sedan måste vi definiera dess namn och med det kan vi börja använda den.
Även om det finns flera sätt att deklarera en array, är den föredragna den korta formen som vi ser nedan:
typ [] nameArrary = ny typ [längd];
I fallet med en array flerdimensionell vi kan göra samma sak men lägga till nya lager eller dimensioner inom samma deklaration, till exempel:
Tvådimensionell matris:
typ [] [] nameArrary = ny typ [längd] [längd];
Tredimensionell matris:
typ [] [] [] nameArrary = ny typ [längd] [längd] [längd];
Det enda vi måste komma ihåg är att efter tre dimensioner blir saker mycket mer komplexa, men detta kommer att dikteras av våra behov vid tidpunkten för programmets utveckling.
För att gå igenom en matris måste vi använda en av de iterativa cykler som vi har tillgängliga, varvid cykeln är för en av favoriterna, eftersom vi kan ange storleken på matrisen och gå igenom vart och ett av dess element.
Vi måste komma ihåg att indexen för matriserna börjar från noll, så i en treelementsmatris skulle deras index vara [0], [1], [2], Detta måste beaktas eftersom det inte är ett traditionellt konto, det kan leda till förvirring.
Ett generiskt exempel på hur man går igenom en array är ungefär som följande:
för (int i = 0; i
På samma sätt som i det lilla exemplet har vi gjort skärmutskrift av innehållet i motsvarande index, vi kan också göra sekventiella tilldelningar och andra operationer med matrisen. När det gäller en flerdimensionell array måste vi göra en cykel för var och en av de dimensioner som vi har, det är därför vi talar om att efter mer än tre dimensioner blir en array mycket komplex.
Vi ska bygga en liten kod där vi kommer att definiera en array, sedan ska vi ta en rundtur i dess element och vi kommer att visa dem på skärmen. Så låt oss se hur vår kod ser ut:
public class ExempelArray1 {public static void main (String [] argv) {int [] ourArray = new int [12]; för (int i = 0; i <12; i ++) {ourArray [i] = i +1; System.out.println ("Matrisens innehåll i: [" + i + "] är:" + ourArray [i]); } System.out.println ("Matrisens totala längd är:" + ourArray.length); }} I det här programmet, det första vi gör efter att ha definierat vår klass och metoden huvud är att definiera en matris av typen som heter int vårt Array som vi tilldelar en längd på 12 element, sedan med en for loop som går från 0 till 11 kommer vi att tilldela ett värde till var och en av indexen i arrayen, sedan gör vi det omedelbart, vi skriver ut dess värde och slutligen använder vi egendomen längd av matrisen som gör att vi kan få sin totala längd och vi skriver ut den lika.
Om vi ser detta i vår konsol när vi kör programmet får vi följande:
FÖRSTORA
Användningen av matriser är mycket populär och mycket användbar, men det finns tillfällen då dess begränsningar börjar synas, särskilt när vi arbetar med mycket dynamiska strukturer där vi inte vet hur många element vi kommer att ha i slutet och där vi behöver en lite mer funktionalitet förutom iterationer för att gå igenom dess element.
När vi ser oss själva i behovet av att vara mer komplexa i hanteringen av data kan vi gå till samlingar, som inte är mer än ett antal klasser grupperade i standardbiblioteket för Java java.util och som gör att vi kan skapa andra typer av datastrukturer.
I det här fallet kommer vi att utforska klassen lite ArrayList, som tillåter oss att skapa listor med arrays som namnet indikerar, men för att manipulera dess element måste vi göra det genom dess olika metoder.
Låt oss se nedan en liten lista över de tillgängliga metoderna för klassen ArrayList viktigare och att vi kan behöva skapa våra program, om vi behöver något extra kan vi alltid tillgripa den officiella dokumentationen för språket.
Lägg till ()Denna metod låter oss lägga till ett element i listan antingen i slutet eller i en viss position, detta definieras genom att passera parametrarna.
klar ()Rengör strukturen genom att radera eller tömma alla element som den innehåller.
skaffa sig ()Det returnerar värdet för det angivna indexet för den aktuella listan.
avlägsna ()Denna metod gör att vi kan ta bort ett visst element från datastrukturen.
toArray ()Denna metod gör att vi kan göra en matrisomvandling av innehållet i listan eller datastrukturen.
Att deklarera en lista med ArrayList, vi måste helt enkelt skapa en instans av den här klassen, med detta kan vi börja arbeta med tilldelning av element och innehåll, för detta kan vi se följande syntax:
ArrayList ourList = new ArrayList ();
Även om vi också kan använda en deklaration och samtidig tilldelning av element som vi ser i följande kodrad:
List ourList = Arrays.asList ("Pedro", "Juan", "Manuel");Turnén i vår lista kan uppnås med en iterativ cykel med för () som vi redan såg i matriserna, är skillnaden att eftersom vi inte säkert vet antalet element i våra listor måste vi definiera gränsen med hjälp av metoden storlek () av samma och för att få innehållet i ett visst index använder vi metoden skaffa sig (). Ett exempel på syntaxen för denna genomgång kan vara följande:
för (int i = 0; i
Nu ska vi skapa ett litet program där vi omsätter det vi har sett om i praktiken ArrayList och på detta sätt specificera en inlärning om nämnda datastruktur:
importera java.util.ArrayList; public class ExempelLista1 {public static void main (String [] argv) {ArrayList ourList = new ArrayList (); ourList.add ("Peter"); ourList.add ("John"); ourList.add ("Francisco"); ourList.add ("Manolo"); ourList.add ("Paul"); för (int i = 0; iI den här koden ser vi att det första vi gör är att importera klassen ArrayList av paketet java.util, om vi inte gör det kommer vi inte att kunna använda det.
Sedan har vi definierat en ny lista med typelement Sträng, då kommer vi att göra listan populär med hjälp av metoden Lägg till ()Som vi kan se har vi inte definierat en elementgräns, den här listan kommer att växa dynamiskt när vi lägger till element i den.
Slutligen med en cykel för () och använder metoden storlek () i vårt listobjekt går vi igenom dess element och för att få värdet för varje position använder vi metoden skaffa sig () med detta kan vi sedan skriva ut innehållet. Låt oss se hur det ser ut när vi kör det på vår konsol:
FÖRSTORA
