Arrayer i Java

Föreställ dig skåp i ett förråd. Var och en av dem har sitt eget nummer, och var och en av dem lagrar något bagageobjekt. Eller en vinlista där alla sorters vin är numrerade och du beställer genom att ange numret på din drink. Eller en lista över elever där "Adams" är inspelad på första plats och "Zimmer" är sist. Eller en lista över passagerare på ett flygplan, som var och en tilldelas ett numrerat säte. I Java används ofta arrays för att arbeta med sådana strukturer, dvs uppsättningar av homogena data.

Vad är en array?

En array är en datastruktur som lagrar element av samma typ. Du kan tänka på det som en uppsättning numrerade celler. Du kan lägga en del data i varje cell (ett dataelement per cell). En specifik cell nås med dess nummer. Ett elements nummer i arrayen kallas också ett index . I Java är en array homogen, dvs alla dess celler innehåller element av samma typ. Således innehåller en array av heltal endast heltal ( int ), en array av strängar - bara strängar, och en array av instanser av en Dog -klass som vi har skapat kommer endast att innehålla Dog- objekt. Med andra ord låter Java oss inte sätta ett heltal i den första cellen i arrayen, en sträng i den andra och en hund i den tredje.

Deklarerar en array

Hur deklarerar man en array?

Som vilken variabel som helst måste en array deklareras i Java. Detta kan göras på ett av två sätt. De är likvärdiga, men det första sättet är mer förenligt med Java-stil. Det andra är ett arv från C-språket: många C-programmerare bytte till Java, och en alternativ metod behölls för deras bekvämlighet. Tabellen visar båda sätten att deklarera en array i Java: I båda fallen är dataType typen av variabler i arrayen. I exemplen deklarerade vi två arrayer. En kommer att lagra int s, och den andra — Objektobjekt . Således har en arraydeklaration ett namn och en typ (typen av elementen i arrayen). ArrayName är namnet på arrayen.

Skapar en array

Hur skapar man en array?

Som alla andra objekt kan du skapa en Java-array, dvs reservera en plats i minnet för den, med den nya operatorn. Så här går det till:

new typeOfArray[length]; 

där typeOfArray är arrayens typ och längd är dess längd (dvs. antalet celler) uttryckt som ett heltal ( ) int. Men observera att här har vi bara allokerat minne för arrayen - vi har inte associerat den deklarerade arrayen med någon tidigare deklarerad variabel. Vanligtvis deklareras en array först och instansieras sedan, till exempel:

int[] myArray; // Array declaration
myArray = new int[10]; // Create (allocate memory for) an array of 10 ints

Här skapade vi en array av heltal som heter myArray , och informerade kompilatorn om att den består av 10 celler (som var och en kommer att innehålla ett heltal). Det är dock mycket vanligare att använda följande förkortade syntax för att skapa en array direkt när den deklareras:

int[] myArray = new int [10]; // Declare the array and allocate memory "in one blow"

Vänligen notera:När en array har skapats med den nya operatorn innehåller dess celler standardvärden. För numeriska typer (som i vårt exempel) är standardvärdet 0, för den booleska typen är det false och för referenstyper är det null . Alltså efter att ha utfört detta uttalande

int[] myArray = new int[10];

vi får en matris med tio heltal och, tills programmet gör något för att ändra värdena, innehåller varje cell 0.

Arraylängd i Java

Som vi sa ovan är längden på en array antalet element som arrayen är utformad för att hålla. Längden på en array kan inte ändras efter att den har skapats. Vänligen noteraatt matriselement är numrerade med början från noll i Java. Således, om vi har en matris med 10 element, är indexet för det första elementet 0 och indexet för det sista är 9. Du kan få matrislängden med hjälp av längdvariabeln . Till exempel:

int[] myArray = new int[10]; // Create an int array for 10 elements and name it myArray
System.out.println(myArray.length); // Display the array's length, i.e. the number of elements we can put into the array

Produktion:

10

Initiera en array och komma åt dess element

Nu vet vi hur man skapar en array i Java. Processen ger oss inte en tom array, utan en array fylld med standardvärden. Till exempel, för en int- matris är detta 0, och om vi har en matris av någon referenstyp är standardvärdet i varje cell null . Vi kommer åt ett matriselement (till exempel för att ställa in dess värde, visa det på skärmen eller utföra någon operation med det) genom dess index. Arrayinitiering är processen att fylla en array med specifika värden (andra än standardvärden). Exempel: låt oss skapa en strängarray för de fyra årstiderna och fylla den med namnen på årstiderna.

String[] seasons = new String[4]; /* Declare and create an array. Java allocates memory for an array of 4 strings, and each cell is set to null (since String is a reference type) */ 

seasons[0] = "Winter"; /* We set the first cell, i.e. the cell with index zero, to "Winter". Here we access the zeroth element of the array and write a specific value to it. */ 
seasons[1] = "Spring"; // We follow a similar procedure for the cell with index 1 (the second cell)
seasons[2] = "Summer"; // ... index 2
seasons[3] = "Autumn"; // and finally, index 3

Nu skrivs årstidernas namn till de fyra cellerna i vår array. Vi skulle kunna initiera arrayen på ett annat sätt, genom att kombinera deklarationen och initieringen:

String[] seasons = new String[] {"Winter", "Spring", "Summer", "Autumn"};

Dessutom kan den nya operatören utelämnas:

String[] seasons = {"Winter", "Spring", "Summer", "Autumn"};

Hur visar man en array på skärmen i Java?

Du kan visa arrayelement på skärmen (dvs på konsolen) med hjälp av en for- loop. Ett annat, kortare sätt att visa en array kommer att diskuteras i avsnittet " Användbara metoder för att arbeta med arrayer" . Under tiden, ta en titt på det här exemplet där en array visas med en loop:

String[] seasons = new String {"Winter", "Spring", "Summer", "Autumn"}; 
for (int i = 0; i < 4; i++) {
System.out.println(seasons[i]); 
}

Programmet kommer att visa följande:

Winter 
Spring 
Summer 
Autumn

Endimensionella och flerdimensionella arrayer i Java

Men vad händer om vi inte vill skapa en array av siffror, strängar eller andra objekt, utan snarare en array av arrayer? Java låter dig göra detta. Den typ av array vi redan känner till ( int[] myArray = new int[8] ) är känd som en endimensionell array. Men en array av arrayer kallas en tvådimensionell array. Det är som en tabell som har ett radnummer och ett kolumnnummer. Eller, om du har lärt dig grunderna i linjär algebra, kan du se det som en matris. Varför behöver vi sådana arrayer? Jo, för att programmera matriser och tabeller, samt andra objekt som har en liknande struktur. Till exempel kan ett schackbräde representeras av en 8x8-array. En flerdimensionell array deklareras och skapas enligt följande:

Int[][] myTwoDimentionalArray = new int[8][8];

Denna array har exakt 64 element: myTwoDimentionalArray[0][0] , myTwoDimentionalArray[0][1] , myTwoDimentionalArray [1][0] , myTwoDimentionalArray [1][1] och så vidare upp till myTwoDimentionalArray[7][7] . Så om vi använder det för att representera ett schackbräde, så motsvarar A1 myTwoDimentionalArray[0][0] och E2 motsvarar myTwoDimentionalArray[4][1] . Men hur långt kan vi driva detta? I Java kan du ange en array av arrayer... en array av arrayer av arrayer, och så vidare. Naturligtvis används tredimensionella och högre dimensionella arrayer mycket sällan. Som sagt, du kan använda en tredimensionell array för att programmera en Rubiks kub, till exempel.

Användbara metoder för att arbeta med arrayer

Java har klassen java.util.Arrays för att arbeta med arrayer. I allmänhet är de vanligaste operationerna som utförs på arrayer initialisering (fyllning med element), hämtning av ett element (genom index), sortering och sökning. Att söka och sortera arrayer är ämnen för en annan dag. Å ena sidan är det bra att skriva flera sök- och sorteringsalgoritmer själv. Å andra sidan har alla de bästa algoritmerna redan implementerats och inkluderats i standard Java-bibliotek, och du kan lagligt använda dem. Här är tre användbara metoder i den här klassen.

Sortera en array

Metoden void sort(int[] myArray, int fromIndex, int toIndex) sorterar en heltalsmatris eller delmatris i stigande ordning.

Söker efter ett element i en array

int binarySearch(int[] myArray, int fromIndex, int toIndex, int-nyckel) . Den här metoden letar efter nyckelelementet i en sorterad myArray- array eller subarray, från fromIndex till toIndex . Om objektet hittas returnerar det dess index. Annars returnerar den (-fromIndex)-1 .

Konvertera en array till en sträng

Metoden String toString(int[] myArray) konverterar en array till en sträng. I Java åsidosätter inte arrayer toString() . Detta betyder att om du försöker visa en hel array på en gång (System.out.println(myArray)) istället för ett element åt gången som i stycket med rubriken " Visa en array på skärmen ", får du namnet på klassen och arrayens hexadecimala hash (definierad av Object.toString() ) . Om du är nybörjare kanske du inte förstår förklaringen om toString -metoden. Till en början behöver du inte, men med den här metoden blir det lättare att visa en array. Java låter dig enkelt visa en array utan att använda en loop. Exemplet nedan visar detta.

Ett exempel med sort, binarySearch och toString

Låt oss skapa en array med heltal, visa den med toString , sortera den med sorteringsmetoden och sedan hitta något nummer i den.

class Main {
    public static void main(String[] args) {
        int[] array = {1, 5, 4, 3, 7}; // Declare and initialize the array
        System.out.println(array); // Try to display our array without using the toString method — the result is a hexadecimal number
        System.out.println(Arrays.toString(array)); // Display the array correctly 
        Arrays.sort(array, 0, 4); // Sort the entire array from the zeroth to the fourth element
        System.out.println(Arrays.toString(array)); // Display the sorted array
        int key = Arrays.binarySearch(array, 5); // Look for the number 5 in the sorted array. 
        // The binarySearch method will return the index of the array element we are searching for
        System.out.println(key); // Display the index of the number we searched for 
System.out.println(Arrays.binarySearch(array, 0)); // Now try to find a number that isn't in the array, 
        // and immediately display the result

    }
}

Produktion:

[I@1540e19d 
[1, 5, 4, 3, 7] 
[1, 3, 4, 5, 7] 
3 
-1

Den första strängen är ett försök att visa arrayen utan att använda toString . Den andra är arrayen som visas med toString . Den tredje är den sorterade arrayen. Det fjärde är indexet för talet vi sökte efter (5) i den sorterade matrisen (kom ihåg att vi räknar från noll, så indexet för matrisens fjärde element är 3). I den femte strängen ser vi -1. Detta är ett ogiltigt arrayindex. Det signalerar att numret vi sökte efter (i det här fallet 0) inte finns i arrayen.

Arrayer i ett nötskal

• En arrays väsentliga egenskaper: typen av data som placeras i den, dess namn och dess längd.
  Den sista egenskapen bestäms när arrayen skapas (när minne tilldelas för arrayen). De två första egenskaperna bestäms när matrisen deklareras.

• Matrisstorleken (antal celler) måste vara en int

• Det är omöjligt att ändra längden på en array efter att den har skapats.

• Ett arrayelement kan nås av dess index.

• Element i arrayer, som allt annat i Java, numreras från noll.

• När en array har skapats fylls den med standardvärden.

• Arrayer i Java är inte samma som array i C++. De är nästan som pekare till dynamiska arrayer.

Användbart material om arrayer

Vill du veta mer om arrays? Kolla in artiklarna nedan. Det innehåller mycket intressant och användbart material om detta ämne.