Hur man använder Java ArrayList

ArrayList är en av de mest använda da­ta­struk­tu­rer­na i Java. Den gör det möjligt att dynamiskt modifiera och lagra en samling objekt. I den här hand­led­ning­en in­tro­du­ce­rar vi syntaxen för Java ArrayList och förklarar när den ska användas.

Vad är skill­na­den mellan ArrayList och Array i Java?

Java ArrayList är dynamisk, vilket innebär att den växer och krymper i storlek när element läggs till eller tas bort. Det är värt att notera att ArrayList-klassen är en del av Java Col­lec­tions Framework och inte är till­gäng­lig som standard. Till skillnad från arrayer måste den im­por­te­ras från bib­li­o­te­ket java.util.

Ar­ray­Lists är ett lämpligt val när längden på en Java-lista kan variera. Exempel på detta är lagring av objekt, sökning eller sortering av data samt skapande av listor eller köer.

Däremot är det inte möjligt att ändra storleken på en array. Det innebär att du helst bör veta i förväg hur många objekt arrayen kommer att innehålla. Arrays är lämpliga för hantering av en för­de­fi­ni­e­rad upp­sätt­ning primitiva datatyper såsom int, float, char eller Boolean.

En nackdel med Ar­ray­Lists är att det kan ta längre tid att komma åt dem. Medan arrayer har ett fast kon­ti­nu­er­ligt min­nes­block, lagras objekt i Ar­ray­Lists inte kon­ti­nu­er­ligt. Det är viktigt att ta hänsyn till för­de­lar­na och nack­de­lar­na med da­ta­struk­tu­rer­na så att du kan välja den som fungerar bäst för ditt an­vänd­nings­fall.

Vad är syntaxen för Java ArrayList?

Innan ArrayList skapas måste mot­sva­ran­de klass im­por­te­ras från bib­li­o­te­ket java.util.

import java.util.ArrayList;

Den allmänna syntaxen är:

ArrayList<Type> arrayList= new ArrayList<>();

“Typ” står för re­spek­ti­ve datatyp i Java ArrayList.

Nästa steg är att skapa listor med strings och integers.

ArrayList<String> arrayList= new ArrayList<>();

ArrayList<Integer> arrayList= new ArrayList<>();

Ar­ray­Lists använder mot­sva­ran­de wrap­per­klass för primitiva datatyper så att de behandlas som objekt. Det innebär att du måste ange integer istället för int.

Exempel på Java ArrayList-metoder

Åtgärder som att lägga till eller ta bort element utförs inte på Ar­ray­Lists med Java-ope­ra­to­rer, utan via för­de­fi­ni­e­ra­de metoder. Nedan visar vi de van­li­gas­te ArrayList-metoderna.

Lägga till element

Efter att ha skapat ArrayList “colours” (typString ) lägger vi till olika element med hjälp av metoden .add().

import java.util.ArrayList;
class Main {
    public static void main(String[] args){
        ArrayList<String> colours = new ArrayList<>();
        colours.add("blue");
        colours.add("red");
        colours.add("green");
        System.out.println("ArrayList: " + colours);
    }
}

Detta re­sul­te­rar i:

ArrayList: [blue, red, green]

Ta bort element

För att ta bort objekt från Java ArrayList använder vi metoden .remove() och anger ele­men­tets index.

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> colours = new ArrayList<>();
        colours.add("blue");
        colours.add("red");
        colours.add("green");
        System.out.println("ArrayList: " + colours);
        String colour = colours.remove(1);
        System.out.println("ArrayList: " + colours);
        System.out.println("Removed Element: " + colour);
    }
}

Ut­mat­ning­en visar den mo­di­fi­e­ra­de ArrayList och det element som har tagits bort:

ArrayList: [blue, green]
Removed Element: red

Som med de flesta pro­gram­me­rings­språk börjar räkningen i Java från 0. Det betyder att det borttagna elementet vid index 1 är red.

Åtkomst till element i Java ArrayList

Med hjälp av funk­tio­nen .get() kan vi komma åt ett element på en specifik position.

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> clothes = new ArrayList<>();
        clothes.add("jacket");
        clothes.add("shirt");
        clothes.add("pullover");
        System.out.println("ArrayList: " + clothes);
        String str = clothes.get(2);
        System.out.print("Element at index 2: " + str);
    }
}

Som resultat får vi:

ArrayList: [jacket, shirt, pullover]
Element at index 2: pullover

För­änd­ran­de element

Med .set() kan vi ändra ett element genom att tilldela ett nytt element vid ett specifikt index.

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> colours = new ArrayList<>();
        colours.add("blue");
        colours.add("red");
        colours.add("green");
        System.out.println("ArrayList: " + colours);
        colours.set(2, "yellow");
        System.out.println("Modified ArrayList: " + colours);
    }
}

Nu ser vi yellow istället för green vid index 2:

ArrayList: [blue, red, green]
Modified ArrayList: [blue, red, yellow]

Bestämma längden på Java ArrayList

Antalet element i ArrayList kan enkelt beräknas med hjälp av metoden .size().

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> colours = new ArrayList<>();
        colours.add("blue");
        colours.add("red");
        colours.add("green");
        System.out.println(colours.size());
    }
}

Detta är re­sul­ta­tet:

3

Sortering och iteration genom ArrayList

För att sortera Java ArrayList måste klassen col­lec­tions im­por­te­ras. För ite­ra­tio­nen använder vi en Java for-each-slinga. För varje iteration av slingan matas re­spek­ti­ve element ut till konsolen.

import java.util.ArrayList;
import java.util.Collections;
public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> ages = new ArrayList<Integer>();
        ages.add(20);
        ages.add(54);
        ages.add(17);
        ages.add(9);
        Collections.sort(ages);
        for (int i : ages) {
            System.out.println(i);
        }
    }
}

Elementen i ArrayList visas från minsta till största:

9
17
20
54