Arrays i Java: En referencevejledning
1. Introduktion
I denne vejledning dykker vi dybt ned i et kernekoncept på Java-sproget - arrays.
Vi ser først, hvad der er en matrix, derefter hvordan vi bruger dem; samlet vil vi dække, hvordan man:
- Kom i gang med arrays
- Læs og skriv arrays-elementer
- Loop over en matrix
- Transformer arrays til andre objekter som f.eks Liste eller Strømme
- Sorter, søg og kombiner arrays
2. Hvad er en matrix?
Første ting først skal vi definere, hvad der er en matrix? Ifølge Java-dokumentationen er en matrix et objekt, der indeholder et fast antal værdier af samme type. Elementerne i en matrix er indekseret, hvilket betyder, at vi kan få adgang til dem med tal (kaldet indekser).
Vi kan betragte en matrix som en nummereret liste over celler, hvor hver celle er en variabel, der indeholder en værdi. I Java starter nummereringen ved 0.
Der er primitive type arrays og object type arrays. Det betyder, at vi kan bruge arrays af int, float, boolean, ... Men også arrays af Streng, objekt og brugerdefinerede typer også.
3. Opsætning af en matrix
Nu hvor arrays er veldefinerede, lad os dykke ned i deres anvendelser.
Vi dækker mange emner, der lærer os, hvordan vi bruger arrays. Vi lærer nogle grundlæggende ting som hvordan man erklærer og initialiserer en matrix, men vi dækker også mere avancerede emner som at sortere og søge arrays.
Lad os gå først med erklæring og initialisering.
3.1. Erklæring
Vi begynder med erklæringen. Der er to måder at erklære en matrix på Java:
int [] anArray;eller:
int an OtherArray [];Førstnævnte er mere udbredt end sidstnævnte.
3.2. Initialisering
Nu når det er tid til at se, hvordan man initialiserer arrays. Igen er der flere måder at initialisere en matrix på. Vi ser de vigtigste her, men denne artikel dækker initialisering af arrays i detaljer.
Lad os begynde med en enkel måde:
int [] anArray = ny int [10];Ved at bruge denne metode initialiserede vi en matrix på ti int elementer. Bemærk, at vi skal angive størrelsen på arrayet.
Når du bruger denne metode, vi initialiserer hvert element til dets standardværdi, her 0. Ved initialisering af en række af Objekt, elementer er nul som standard.
Vi ser nu en anden måde, der giver os muligheden for at indstille værdier til arrayet direkte, når vi opretter det:
int [] anArray = ny int [] {1, 2, 3, 4, 5};Her initialiserede vi et fem-element-array, der indeholder numrene 1 til 5. Når vi bruger denne metode, behøver vi ikke specificere længden af arrayet, det er antallet af elementer, der derefter erklæres mellem parenteserne.
4. Adgang til elementer
Lad os nu se, hvordan du får adgang til elementerne i en matrix. Vi kan opnå dette ved at kræve en matrixcelleposition.
For eksempel udskriver dette lille kodestykke 10 til konsollen:
anArray [0] = 10; System.out.println (anArray [0]);Bemærk, hvordan vi bruger indekser til at få adgang til array-cellerne. Tallet mellem parenteserne er den specifikke position for det array, vi vil have adgang til.
Hvis det passerede indeks er negativt eller går ud over den sidste celle, får Java adgang til en celle ArrayIndexOutOfBoundException.
Vi skal være forsigtige ikke at bruge et negativt indeks eller et indeks, der er større end eller lig med arraystørrelsen.
5. Iteration Over an Array
Adgang til elementer en efter en kan være nyttig, men vi vil måske gentage gennem en matrix. Lad os se, hvordan vi kan opnå dette.
Den første måde er at bruge til løkke:
int [] anArray = ny int [] {1, 2, 3, 4, 5}; for (int i = 0; i <anArray.length; i ++) {System.out.println (anArray [i]); }Dette skulle udskrive nummer 1 til 5 på konsollen. Som vi kan se, brugte vi længde ejendom. Dette er en offentlig ejendom, der giver os størrelsen på arrayet.
Det er selvfølgelig muligt at bruge andre loop-mekanismer som f.eks mens eller gøre imens. Men som med Java-samlinger er det muligt at løbe over arrays ved hjælp af for hver løkke:
int [] anArray = ny int [] {1, 2, 3, 4, 5}; for (int element: anArray) {System.out.println (element); }Dette eksempel svarer til det foregående, men vi slap af med indeksen kedelpladekode. Det for hver loop er en mulighed, når:
- vi behøver ikke at ændre arrayet (at sætte en anden værdi i et element vil ikke ændre elementet i arrayet)
- vi har ikke brug for indekserne for at gøre noget andet
6. Varargs
Vi har allerede dækket det grundlæggende, når det kommer til oprettelse og manipulation af arrays. Nu dykker vi ned i mere avancerede emner begyndende med varargs. Som en påmindelse, varargs bruges til at overføre et vilkårligt antal argumenter til en metode:
ugyldig varargsMethod (streng ... varargs) {}Denne metode kan tage fra 0 til et vilkårligt antal Snor argumenter. En artikel, der dækker varargs kan findes her.
Hvad vi skal vide her er, at inde i metodekroppen, a varargs parameter bliver til en matrix. Men, Vi kan også videregive en matrix direkte som argumentet. Lad os se, hvordan ved at genbruge eksemplet metode beskrevet ovenfor:
Streng [] anArray = ny streng [] {"Mælk", "Tomat", "Chips"}; varargsMethod (anArray);Vil opføre sig som:
varargsMethod ("mælk", "tomat", "chips");7. Omdannelse af en matrix til en liste
Arrays er gode, men nogle gange kan det være lettere at håndtere Liste i stedet. Vi ser her, hvordan man transformerer en matrix til en Liste.
Vi gør det først på den naive måde ved at oprette en tom liste og gentage over matrixen for at tilføje dens elementer til listen:
int [] anArray = ny int [] {1, 2, 3, 4, 5}; Liste aList = ny ArrayList (); for (int element: anArray) {aList.add (element); }Men der er en anden måde, lidt mere kortfattet:
Heltal [] anArray = nyt Heltal [] {1, 2, 3, 4, 5}; Liste aList = Arrays.asList (anArray);Den statiske metode Arrays.asList tager en varargs argument og opretter en liste med de beståede værdier. Desværre har denne metode nogle ulemper:
- Det er ikke muligt at bruge en række primitive typer
- Vi kan ikke tilføje eller fjerne elementer fra den oprettede liste, da det kaster et Ikke-understøttetOperationException
8. Fra en matrix til en strøm
Vi kan nu omdanne arrays til lister, men siden Java 8 har vi adgang til Stream API og vi vil måske gøre vores arrays til Strøm. Java giver os Arrays.stream metode til det:
Streng [] anArray = ny streng [] {"Mælk", "Tomat", "Chips"}; Stream aStream = Arrays.stream (anArray);Når du passerer en Objekt array til metoden, det returnerer a Strøm af den matchende type (f.eks. Strøm for en række Heltal). Når du passerer en primitiv, returnerer den den tilsvarende primitive Strøm.
Det er også muligt kun at oprette streamen på et undersæt af arrayet:
Stream anotherStream = Arrays.stream (anArray, 1, 3);Dette vil skabe en Strøm med kun "tomat" og "chips" Strenge (det første indeks inkluderer, mens det andet er eksklusivt).
9. Sorteringsarrays
Lad os nu se, hvordan man sorterer en matrix, der omarrangerer dens elementer i en bestemt rækkefølge. Det Arrays klasse giver os den sortere metode. Lidt som strøm metode, sortere har en masse overbelastninger.
Der er overbelastning at sortere:
- Primitive type arrays: som er sorteret i stigende rækkefølge
- Objekt arrays (disse Objekt skal implementere Sammenlignelig interface): der er sorteret efter den naturlige rækkefølge (afhængig af sammenligne med metode fra Sammenlignelig)
- Generiske arrays: som er sorteret efter et givet Komparator
Derudover er det kun muligt at sortere en bestemt del af et array (videregive start- og slutindeks til metoden).
Algoritmerne bag sortere metode er hurtig sortering og flet sortering til henholdsvis primitive og andre arrays.
Lad os se, hvordan alt dette fungerer gennem nogle eksempler:
int [] anArray = ny int [] {5, 2, 1, 4, 8}; Arrays.sort (anArray); // anArray er nu {1, 2, 4, 5, 8} Heltal [] anotherArray = nyt heltal [] {5, 2, 1, 4, 8}; Arrays.sort (anotherArray); // anotherArray er nu {1, 2, 4, 5, 8} String [] yetAnotherArray = new String [] {"A", "E", "Z", "B", "C"}; Arrays.sort (yetAnotherArray, 1, 3, Comparator.comparing (String :: toString) .reversed ()); // yetAnotherArray er nu {"A", "Z", "E", "B", "C"}10. Søgning i en matrix
Det er ret simpelt at søge i et array, vi kan løbe over arrayet og søge i vores element blandt arrayelementerne:
int [] anArray = ny int [] {5, 2, 1, 4, 8}; for (int i = 0; i <anArray.length; i ++) {if (anArray [i] == 4) {System.out.println ("Fundet ved indeks" + i); pause; }}Her søgte vi efter nummer 4 og fandt det i indeks 3.
Hvis vi dog har et sorteret array, kan vi bruge en anden løsning: binær søgning. Princippet om binær søgning forklares i denne artikel.
Heldigvis giver Java os Arrays.binarySearch metode. Vi er nødt til at give det en matrix og et element, der skal søges.
I tilfælde af et generisk array skal vi også give det Komparator der blev brugt til at sortere arrayet i første omgang. Der er igen mulighed for at kalde metoden på et undersæt af arrayet.
Lad os se et eksempel på brugen af binær søgemetode:
int [] anArray = ny int [] {1, 2, 3, 4, 5}; int index = Arrays.binarySearch (anArray, 4); System.out.println ("Fundet ved indeks" + indeks);Da vi lagrede nummer 4 i den fjerde celle, returnerer dette indeks 3 som resultat. Bemærk, at vi brugte et allerede sorteret array.
11. Sammenkædning af arrays
Lad os endelig se, hvordan du sammenkæder to arrays. Ideen er at oprette en matrix, som er summen af de to arrays, der skal sammenkædes. Derefter skal vi tilføj elementerne i den første og derefter elementerne i den anden:
int [] anArray = ny int [] {5, 2, 1, 4, 8}; int [] anotherArray = new int [] {10, 4, 9, 11, 2}; int [] resultArray = new int [anArray.length + anotherArray.length]; for (int i = 0; i <resultArray.length; i ++) {resultArray [i] = (i <anArray.length? anArray [i]: anotherArray [i - anArray.length]); }Som vi kan se, når indekset stadig er mindre end den første array-længde, tilføjer vi elementer fra det array. Derefter tilføjer vi elementer fra den anden. Vi kan gøre brug af Arrays.setAll metode til at undgå at skrive en løkke:
int [] anArray = ny int [] {5, 2, 1, 4, 8}; int [] anotherArray = new int [] {10, 4, 9, 11, 2}; int [] resultArray = new int [anArray.length + anotherArray.length]; Arrays.setAll (resultArray, i -> (i <anArray.length? AnArray [i]: anotherArray [i - anArray.length]));Denne metode indstiller alle matrixelementer i henhold til den givne funktion. Denne funktion forbinder et indeks med et resultat.
Her er en tredje mulighed for at flette til arrays: System.arraycopy. Denne metode tager en kilde array, en kildeposition, en destination array, en destinationsposition og en int definerer antallet af elementer, der skal kopieres:
System.arraycopy (anArray, 0, resultArray, 0, anArray.length); System.arraycopy (anotherArray, 0, resultArray, anArray.length, anotherArray.length);Som vi kan se, kopierer vi den første matrix, derefter den anden (efter det sidste element i den første).
12. Konklusion
I denne detaljerede artikel har vi dækket grundlæggende og nogle avancerede anvendelser af arrays i Java.
Vi så, at Java tilbyder mange metoder til at håndtere arrays gennem Arrays utility klasse. Der er også hjælpeklasser til at manipulere arrays i biblioteker som Apache Commons eller Guava.
Den fulde kode til denne artikel kan findes på vores GitHub.
