ArrayList i Java: En föränderlig array

I den här artikeln ska vi lära oss om klassen ArrayList som är en standardklass i Java som möjliggör att arbeta med föränderliga samlingar av data. Vi kommer lära oss om en rad olika metoder för att arbeta med en ArrayList och sedan använda dem för att lösa ett längre exempel.

Vad är en ArrayList i Java ?

Till att börja med, klassen ArrayList är en standardklass i Java som möjliggör att arbeta med föränderliga samlingar av data. Det betyder att en ArrayList gör det enkelt och smidigt att arbeta med data som kan komma att förändras i antal under arbetets gång. Skillnaden mellan en inbyggd array, som vi såg på föregående sidor, och en ArrayList är att storleken på en array inte kan ändras. Det vill säga, om du vill lägga till eller ta bort element i en array, måste du skapa en ny, medans element till en ArrayList kan du lägga till och ta bort när du vill.

Vidare, vi kan illustrera en ArrayList på liknande sätt som en array och tänka oss att vi har flera lagringsplatser som bara forsätter.

Hur skapar man en ArrayList i Java?

Även om en ArrayList har stora likheter med en array när det gäller deklarationen, så är det några saker som skiljer dem åt. Till att börja med, vi kan endast kan spara objekt i en ArrayList och behöver därför ange omslagsklassen (engelska: wrapper class) vid deklarationen, det vill säga att vi kan inte spara primitiva datatyper i en ArrayList. En omslagsklass är den typ av data vi vill spara i vår ArrayList. Vi ska nedan se en tabell med den primitiva datatypen och deras respektive omslagsklass.

Syntax: Deklarera en ArrayList i Java

Vidare, syntax för att deklarera och arbeta med en ArrayList jämfört med en array skiljer sig också åt lite.

 // importerar klassen ArrayList
import java.util.ArrayList;

// Deklarera en ArrayList
ArrayList <Omslagsklass> namn = new ArrayList <Omslagsklass>(); 

Låt oss ta det stegvis,

• Först behöver vi ange import java.util.ArrayList; för att importera klassen ArrayList så vi kan använda alla de inbyggda metoderna och funktionerna.
• Sedan för vår ArrayList så börjar vi med att ange det reserverade ordet ArrayList, följt av < Omslagsklass >. Notera att istället för hakparenteser, [ ], som vi använde för en array ska vi nu använda, < > istället. En omslagsklass är den typ av data vi vill spara i vår ArrayList.
• Vidare, så anger vi det namn vi vill använda följt av lika-med tecknet  =  och de reserverade orden new och ArrayList.
• Slutligen så anger vi samma < Omslagsklass > igen och avslutar med ( );. Notera parenteserna i slutet av deklarationen, vilket vi måste ange för att få en giltig deklaration av vår ArrayList.

Primitiv datatyp med tillhörande omslagsklass

Som vi nämnde ovan så kan vi endast kan spara objekt i en ArrayList och behöver därför ange omslagsklassen (engelska: wrapper class) vid deklarationen. Nedan är en tabell med den primitiva datatypen och den tillhörande omslagsklassen.

Primitiv datatyp	Omslagsklass
byte	Byte
char	Character
int	Integer
double	Double
boolean	Boolean
float	Float

Hur använder man en ArrayList i Java?

Som vi nu har beskrivit så finns det stora likheter mellan en ArrayList och en Array i Java. Men, förutom den stora skillnaden att en ArrayList är en föränderlig lista av data, så är det skillnader i de kommandon vi använder när vi arbetar med en ArrayList jämfört med en array. Med andra ord, de kommandon vi kan utföra är i stort sett samma, men sättet vi deklarerar dessa kommandon och anropar olika metoder skiljer sig åt.

Låt oss gå igenom några användbara egenskaper för att arbeta med en ArrayList. Vi börjar med att skapa en lista av integers som vi döper till listEx som vi ska använda oss av.

 // importerar klassen ArrayList
import java.util.ArrayList;

// Deklarera en ArrayList
ArrayList <Integer> listEx = new ArrayList <Integer> (); 

Lägga till element i en ArrayList

För att lägga till ett element i vår ArrayList använder vi den inbyggda metoden add().

// Lägga till element i en ArrayList
listEx.add(12);
listEx.add(5);
listEx.add(23);
listEx.add(8);

Det metoden gör är att lägga till elementet på den första lediga platsen i listan. Med andra ord, vi kommer få:

Om vi däremot vill lägga till ett element på en specific plats i listan, alltså ett givet index, så använder vi metoden add() igen och skriver det index, ett kolon, och sedan värdet inom parentesen.

// Lägga till element i en ArrayList på specifikt index
listEx.add(3,62);
listEx.add(1,999);

Det metoden gör är att lägger in elementet på det index vi angav och flyttar sedan alla andra element ett steg åt höger. I exemplet vi jobbar så kommer det resultera i

Viktigt att notera: vi kan inte lägga till element utanför längden på listan. Det betyder att vi kan inte ha ett mellanrum mellan de element som är initierade i listan. Exempelvis, att vi har element på index 0 – 5 och sedan på index 8.

Om vi skulle försöka lägga till ett element på, till exempel, index 8 i vår lista, listEx i figuren ovan, så kommer vi få ett felmeddelande som säger:

java.lang.IndexOutOfBoundsException: Index: 8, Size: 6

Använda ett element i en ArrayList

Okej, men nu har vi sparat ned ett par värden i vår ArrayList som heter listEx, och nu vill vi använda dom. För att läsa av ett element i ArrayList så används metoden get () och vi anger indexnumret på det element vi vill läsa av. Exempelvis,

// Hämtar värdet
int number = listEx.get(4); 

Så kommer variabeln number att vara lika med 62.

Däremot, om vi vill ändra ett element i listan så använder vi metoden set() och anger det indexnumret vi vill ändra, ett kolon, och sedan det värde vi vill ändra till.

// Ändrar värdet 
listEx.set(4, 45);

// Hämtar värdet igen 
int number = listEx.get(4);

Så kommer värdet på number att istället bli 45.

Ta bort ett element i en ArrayList

Vidare, vill vi ta bort ett element från vår lista så använder vi metoden remove() och anger vilket index i listan det är vi vill ta bort. Till exempel, om vi vill ta bort det element vi adderade på index 1 i listan

// Tar bort elementet på index 1
listEx.remove(1);

Så kommer elementet på index att försvinna och alla element som kommer senare i listan, alltså till höger i vår figur, kommer att flyttas ett steg åt vänster. Om vi tar och uppdaterar vår figur för listEx så får vi:

Längden av en ArrayList

Om vi vill veta hur lång en ArrayList är så skriver vi namnet på den ArrayList vi arbetar med, följt av .size(). Funktionen size() anger antalet element som finns i listan, och inte det infogade värdet. Exempelvis,

// Antalet element i listan listEx
listEx.size(); 

Vidare, om vi tar och skriver ut längden för listan

// Skriva ut antalet element i listan
System.out.println("Längden på listan: " + listEx.size());

Får vi resultatet

Längden på listan: 5

Notera att, på liknande sätt som för en array, så kommer längden på en ArrayList att vara ett större än index. Det beror helt enkelt på att index alltid börjar på 0 och längden beräknas som antal element.

Loopa igenom en ArrayList

Om vi vill loopa igenom en lista från början till slut så gör vi det på samma sätt som för en array, där vi med fördel använder oss av en for-loop. Till exempel, vi vill nu summera alla värden som vi har sparat i listEx.

// För att kunna summera ihop värdena
int total = 0;  

// For-loop för att loopa igenom ArrayList
for (int i = 0; i < listEx.size(); i++) {

   // Räkna ihop summan
   total = total + listEx.get(i);      
}
// Skriva ut totalen
System.out.println("Summan av elementen i listan är: " + total);  

Vilket resulterar i

Summan av elementen i listan är: 110

Notera att vi i for-loopen använder metoden size(), istället för length som vi använde när vi arbetade med en array.

Hitta index av ett specifikt värde i en ArrayList

Med hjälp av metoden indexOf() kan vi söka igenom en ArrayList och returnera det index där det givna värde finns. Metoden returnerar index av första förekomsten av det elementet vi letar efter, och ifall elementet inte hittas i listan så returneras -1.

// Leta efter värdet 8
listEx.indexOf(8);

// Leta efter värdet 95
listEx.indexOf(95); 

Så kommer metoderna returnera

4 
-1

Sortera en ArrayList

En annan användbar klass i paketet java.util är klassen Collections, som inkluderar metoden sort () som vi kan använda för att sortera listor alfabetiskt eller numeriskt.

// Import collections klassen
import java.util.Collections; 
 
// Sortera elementen i listan 
Collections.sort(listEx);

Om vi tar och uppdaterar vår figur för listEx så får vi:

Ta bort alla element i en ArrayList

För att ta bort alla element i en ArrayList använder vi metoden clear().

// Ta bort alla element i listEx
listEx.clear(); 

Sammanställning av metoder för ArrayList

Nedan är en sammanställning av några av de mest användbara metoderna för ArrayList i Java.

Metod	Beskrivning
add()	Lägger till element till listan
addAll()	Lägger till alla element i en lista till en annan lista
clear()	Tar bort alla element från listan
contains()	Returnerar true om listan innehåller det specificerade elementet
get()	Returnerar elementet på den angivna positionen i listan
indexOf()	Returnerar index för den första förekomsten av det angivna elementet i listan, eller -1 om listan inte innehåller elementet
isEmpty()	Returnerar true om listan inte innehåller några element.
lastIndexOf()	Returnerar index för den sista förekomsten av det angivna elementet i listan, eller -1 om listan inte innehåller elementet.
remove()	Tar bort elementet på den angivna positionen i listan
set()	Ersätter elementet på den angivna positionen i listan med det angivna elementet
size()	Returnerar antalet element i listan
sort()	Sorterar listan i alfabetisk eller numerisk ordning
toArray()	Konverterar en lista till en array som innehåller alla element från listan

För en komplett lista på alla metoder, se dokumentationen för klassen ArrayList hos Oracle.

Exempel: ArrayList i Java

Nu har vi gått igenom en rad olika metoder som vi kan använda när vi jobbar med en ArrayList. Men låt oss nu försöka använda flera av dom för att lösa en exempeluppgift.

Det vi ska göra är att skriva ett program där användaren ska kunna ange deltagare till en lista. Programmet ska ge användaren ett par val, som en enklare meny, och baserat på vilken siffra som anges ska följande funktioner utföras.

• 1: Lägga till ett deltagarnamn i listan.
• 2: Ta bort en deltagare med hjälp av index från listan.
• 3: Hitta deltagarnummer (index) till en deltagare.
• 4: Skriv ut en lista med alla deltagare i listan och deras respektive deltagarnummer.
• 5: Sortera listan i alfabetisk ordning.
• 9: Avsluta programmet.

Om användaren anger ett felaktig input till menyn så ska vi skriva ut det och användaren får försöka igen. Vidare, det första vi gör sen är att importera klassen Scanner, ArrayList och Collections.

// Importerar klassen Scanner
import java.util.Scanner;

// Importerar klassen ArrayList
import java.util.ArrayList;

// Importerar klassen Collections
import java.util.Collections;

Vidare, sedan skapar vi vår ArrayList och Scanner objekt för att kunna ta in information av användaren och ha någonstans att spara ned informationen.

// Spara ned deltagarnamnen i en lista
ArrayList <String> userNames = new ArrayList <String> ();

// Input från användaren
Scanner in = new Scanner(System.in);

// Kontrollera att programmet ska köras
boolean runProg = true;

Nästa vi gör är att ställa upp den while-loop och else-if satser vi kommer använda.

while (runProg){

    System.out.println("Ange 1 för att lägga till en deltagare" +
        "\nAnge 2 för att ta bort en deltagare" +
        "\nAnge 3 för att hitta deltagarnummer till en deltagare" +
        "\nAnge 4 för att skriva ut en lista med alla deltagare" +
        "\nAnge 5 för att sortera listan i alfabetisk ordning" +
        "\nAnge 9 för att avsluta programmet" );

    int input = in.nextInt();

    if (input == 1){
        System.out.println("Ange namn på deltagare: ");
            userNames.add(in.next());
    }

    else if (input == 2){
        System.out.println("Ange deltagarnummer för deltagare: ");
            userNames.remove(in.nextInt());
    }

    else if (input == 3){
        System.out.println("Ange namn på deltagare: ");

        String findName = in.next();
        
        if (userNames.indexOf(findName) != -1){
            System.out.println("Deltagare: " + findName +
                " finns på index: " + userNames.indexOf(findName)+ "\n");
            }
        else{
            System.out.println("Deltagare: " + findName +
                " hittades ej i listan");
        }
    }

    else if (input == 4){
        for (int i = 0; i < userNames.size(); i++){
            System.out.println("Nummer: " + i +
                 "\t Namn: " + userNames.get(i));
        }
        System.out.println();
    }
    else if(input == 5){
        Collections.sort(userNames);
        System.out.println("Listan är sorterad i alfabetisk ordning\n");
    }

    else if (input == 9){
        System.out.println("Programmet avslutas");
        runProg = false;
    }

    else {
        System.out.println("Felaktig info. Prova igen\n");
    }
}

Avslutningsvis, skulle du vilja testa hela koden i exemplet ovan kan du göra det genom att klicka på knappen nedan.

Sammanfattning av ArrayList i Java

Om vi ska kortfattat sammanfatta en ArrayList i Java i tre punkter så är det:

• En standardklass som möjliggör att arbeta med föränderliga samlingar av data.
• Enbart möjligt att spara objekt i en ArrayList. Därför behöver vi ange omslagsklassen (engelska: wrapper class) vid deklarationen, det vill säga att vi kan inte spara primitiva datatyper i en ArrayList.
• För att arbeta med en lista i Java så finns det flertalet inbyggda metoder i klassen ArrayList. En sammanställning av de mest användbara metoder finns högre upp på den här sidan eller hos dokumentationen för klassen ArrayList hos Oracle.

Vanliga frågor och svar: ArrayList i Java