Lad os begynde vores introduktion til List datastrukturen. Nedenfor ses et flowchart, der illustrerer hierarkiet af Collections og Lists. Det kan virke som et stort og komplekst diagram, men vi gennemgår det trin for trin.

I dette afsnit udforskes en specifik type collection kaldet lists. Du får et nærmere kig på forskellige listetyper, herunder ArrayList, LinkedList og Stack.

Da alle lists arver fra List-interfacet, kan objekter oprettes ved hjælp af forældreinterfacet. Vi dykker dybere ned i dette senere.

Lad os for nu diskutere den første type liste – ArrayList.

Ovenfor ses syntaksen for at oprette en ArrayList<>. Der er én del, du måske ikke kender – generics. Vi gennemgår generics og hvordan de oprettes senere.

Husk indtil videre, at når du opretter en ArrayList, angives datatypen i vinkelparenteser. Bemærk også, at lists ikke kan arbejde med primitive datatyper. I stedet anvendes wrapper-klasser.

Nu oprettes en liste i kode, og der tilføjes nogle objekter ved hjælp af add()-metoden.

Main.java


              1234567891011121314
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numberList = new ArrayList<>();
        numberList.add(10);
        numberList.add(15);
        numberList.add(5);
        System.out.println(numberList);
    }
}

Som du kan se, er add()-metoden meget enkel—den tilføjer blot den angivne værdi til listen.

Husk også, at du skal importere List og ArrayList fra java.util-biblioteket. Hvis du bruger IntelliJ IDEA, importerer den dog automatisk disse biblioteker for dig, så du behøver ikke bekymre dig om det.

Lad os nu se et eksempel på at oprette en liste med vores egen datatyp:

Main.java


              1234567891011121314151617181920212223242526272829303132333435
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Dog bob = new Dog("Bob", 2);
        Dog ben = new Dog("Ben", 1);
        Dog brian = new Dog("Brian", 5);
        List<Dog> dogList = new ArrayList<>();
        dogList.add(bob);
        dogList.add(ben);
        dogList.add(brian);
        System.out.println(dogList);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Som du kan se, oprettede vi vores egen klasse Dog og en ArrayList ved hjælp af denne datatype. Når vi udskrev listen, viste den alle objekterne, der var gemt i den.

Hvad nu hvis du har et array og har brug for at konvertere det til en liste? Du kan gøre dette ved hjælp af metoden asList() fra klassen Arrays.

Denne metode giver os mulighed for at oprette en liste, der indeholder de samme elementer som det oprindelige array. Det er især nyttigt, når vi ønsker at anvende listemetoder på et array. Syntaksen er enkel:

Arrays.asList(arrayName);

Og du kan straks bruge det, når du initialiserer en ny liste, for eksempel:

Main.java


              12345678910111213141516171819202122232425262728293031323334
            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Dog bob = new Dog("Bob", 2);
        Dog ben = new Dog("Ben", 1);
        Dog brian = new Dog("Brian", 5);
        Dog[] dogs = {bob, ben, brian};
        List<Dog> dogList = new ArrayList<>(Arrays.asList(dogs));
        System.out.println(dogList);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Ligesom du kan konvertere et array til en liste, kan du også konvertere en liste til et array ved at bruge toArray()-metoden.

ArrayList<>-metoder

Lad os gennemgå de grundlæggende listemetoder. Indtil nu kunne du nemt have erstattet lister med arrays, men her er den væsentlige forskel—metoderne.

add()-metoden er en overloadet metode, hvilket betyder, at den har flere varianter. En af dem gør det muligt at tilføje et element på et bestemt indeks.

Når du indsætter et element midt i en liste, flyttes alle elementer til højre én position for at give plads til det nye element.

Hvis du for eksempel tilføjer et element i begyndelsen af listen, vil alle eksisterende elementer flytte én position til højre.

Lad os se på et eksempel:

Main.java


              123456789101112131415161718
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 0; i < 5; i++) { // Filling `numbers` list with 5 values
            numbers.add(i);
        }
        System.out.println("`numbers` before modifying: " + numbers);
        numbers.add(2, 10); // Adding 10 on the second index
        System.out.println("`numbers` after first modifying: " + numbers);
        numbers.add(0, 5);
        System.out.println("`numbers` after second modifying: " + numbers);
    }
}

Måden, hvorpå værdierne forskydes ved indsættelse af et element, kan visualiseres i følgende illustration:

Hentning af elementer

Hvis det er muligt at tilføje objekter til en liste på et bestemt indeks, er det naturligvis også muligt at hente objekter ved deres indeks ved hjælp af metoden get(int index).

Se følgende eksempel:

Main.java


              12345678910111213141516171819
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        names.add("David");
        names.add("Eva");

        // Retrieving element by index
        String element = names.get(2);  // Retrieving the 3rd element (index starts from 0)
        System.out.println("The element at index 2 is: " + element);
    }
}

Fjernelse af elementer

Du kan tilføje, du kan hente, men kan du slette? Selvfølgelig! Du kan fjerne elementer ved hjælp af metoden remove(int index).

Denne metode er også overloadet, hvilket betyder, at der findes en anden måde at fjerne et element på. Du kan bruge metoden remove(Object obj), som sletter den første forekomst af det angivne element.

Forestil dig nu, at du har en stor liste over alle studerende på vores kursus. Dog opførte én studerende sig dårligt og blev bortvist. Du kender ikke deres præcise indeks, så du skal fjerne dem efter navn. Men der er en udfordring—koden er lidt defekt, og deres navn kan forekomme flere gange på listen.

Lad os skrive et program, der fjerner alle forekomster af denne studerende fra listen:

Main.java


              123456789101112131415161718
            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Charlie", "David", "Eva", "Frank", "Grace", "Hank", "Ivy", "Jack", "Katherine", "Leo", "Mia", "Nathan", "Olivia", "Paul", "Quinn", "Rachel", "Sam", "Tom", "Ursula", "Victor", "Wendy", "Xander", "Yvonne", "Zack", "Bob", "Emily", "Bob", "Jake", "Isabel", "Liam", "Nora", "Bob", "Sophia", "Bob", "Daniel", "Gabrielle", "Mike"};
        // Expelled student: Bob
        List<String> students = new ArrayList<>(Arrays.asList(names));
        System.out.println("Is Bob present in the list? " + students.contains("Bob"));
        while (students.contains("Bob")) {
            students.remove("Bob");
        }
        System.out.println("Is Bob still present in the list after the removal operation? " + students.contains("Bob"));
    }
}

Du har måske bemærket, at vi brugte en anden liste-metode—contains(Object obj). Denne metode kontrollerer, om det angivne element er til stede i listen, og returnerer true eller false.

Ved at bruge contains() sætter vi betingelsen for while-løkken, hvilket gør det muligt at fjerne alle forekomster af en studerende som "Bob" fra listen.

I øvrigt kan du forenkle denne proces betydeligt ved at bruge metoden removeAll(Collection<?> c):

Main.java


              123456789101112131415161718
            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Charlie", "David", "Eva", "Frank", "Grace", "Hank", "Ivy", "Jack", "Katherine", "Leo", "Mia", "Nathan", "Olivia", "Paul", "Quinn", "Rachel", "Sam", "Tom", "Ursula", "Victor", "Wendy", "Xander", "Yvonne", "Zack", "Bob", "Emily", "Bob", "Jake", "Isabel", "Liam", "Nora", "Bob", "Sophia", "Bob", "Daniel", "Gabrielle", "Mike"};
        // Expelled student: Bob
        List<String> students = new ArrayList<>(Arrays.asList(names));
        System.out.println("Is Bob present in the list? " + students.contains("Bob"));
        List<String> expelledStudents = new ArrayList<>();
        expelledStudents.add("Bob");
        students.removeAll(expelledStudents);
        System.out.println("Is Bob still present in the list after the removal operation? " + students.contains("Bob"));
    }
}

Metoden removeAll() tager en samling som parameter, der indeholder værdier, som vil blive fjernet fra listen, hvorpå metoden blev kaldt.

I denne tilgang oprettede vi en samling af udviste studerende og tilføjede "Bob" til den. Dette gør vores kode let udvidelig—du kan blot tilføje flere ballademagere til listen over udviste studerende over tid.

Opdatering af en værdi efter indeks

Lad os vende tilbage til liste-metoder—nu er det tid til opdateringsmetoden.

Da add()-metoden blot flytter alle elementer til højre ved indsættelse af en ny værdi, har vi brug for en anden måde til at opdatere en eksisterende værdi efter indeks.

Metoden set(int index, Object value) gør netop dette:

Main.java


              12345678910111213141516
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> example = new ArrayList<>();
        for (int i = 1; i <= 5; i++) {
            example.add(i);
        }
        System.out.println("List before modification: " + example);
        example.set(2, 28);
        System.out.println("List after modification: " + example);
    }
}

Det er ret ligetil—vi har erstattet elementet ved andet indeks med tallet 28.

Andre metoder

Du har allerede gennemgået de mest almindelige metoder, men der findes mange flere. Da de sjældent bruges, vil vi ikke fokusere på hver enkelt.

I stedet kan du finde alle de nødvendige metoder—sammen med fuldstændig dokumentation og detaljerede forklaringer—ved at åbne ArrayList-klassen i IntelliJ IDEA.

For at gøre dette skal du blot importere ArrayList-biblioteket, holde Command key nede (Ctrl for Windows) og klikke på ArrayList. Dette viser dig alle felter og metoder, der er tilgængelige i klassen, så du kan udforske eventuelle metoder, du måtte have overset.

Var alt klart?

Tak for dine kommentarer!

Sektion 1. Kapitel 2

Spørg AI

Spørg om hvad som helst eller prøv et af de foreslåede spørgsmål for at starte vores chat

Stryg for at vise menuen

I dette afsnit udforskes en specifik type collection kaldet lists. Du får et nærmere kig på forskellige listetyper, herunder ArrayList, LinkedList og Stack.

Da alle lists arver fra List-interfacet, kan objekter oprettes ved hjælp af forældreinterfacet. Vi dykker dybere ned i dette senere.

Lad os for nu diskutere den første type liste – ArrayList.

Ovenfor ses syntaksen for at oprette en ArrayList<>. Der er én del, du måske ikke kender – generics. Vi gennemgår generics og hvordan de oprettes senere.

Nu oprettes en liste i kode, og der tilføjes nogle objekter ved hjælp af add()-metoden.

Main.java


              1234567891011121314
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numberList = new ArrayList<>();
        numberList.add(10);
        numberList.add(15);
        numberList.add(5);
        System.out.println(numberList);
    }
}

Som du kan se, er add()-metoden meget enkel—den tilføjer blot den angivne værdi til listen.

Lad os nu se et eksempel på at oprette en liste med vores egen datatyp:

Main.java


              1234567891011121314151617181920212223242526272829303132333435
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Dog bob = new Dog("Bob", 2);
        Dog ben = new Dog("Ben", 1);
        Dog brian = new Dog("Brian", 5);
        List<Dog> dogList = new ArrayList<>();
        dogList.add(bob);
        dogList.add(ben);
        dogList.add(brian);
        System.out.println(dogList);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Som du kan se, oprettede vi vores egen klasse Dog og en ArrayList ved hjælp af denne datatype. Når vi udskrev listen, viste den alle objekterne, der var gemt i den.

Hvad nu hvis du har et array og har brug for at konvertere det til en liste? Du kan gøre dette ved hjælp af metoden asList() fra klassen Arrays.

Arrays.asList(arrayName);

Og du kan straks bruge det, når du initialiserer en ny liste, for eksempel:

Main.java


              12345678910111213141516171819202122232425262728293031323334
            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Dog bob = new Dog("Bob", 2);
        Dog ben = new Dog("Ben", 1);
        Dog brian = new Dog("Brian", 5);
        Dog[] dogs = {bob, ben, brian};
        List<Dog> dogList = new ArrayList<>(Arrays.asList(dogs));
        System.out.println(dogList);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Ligesom du kan konvertere et array til en liste, kan du også konvertere en liste til et array ved at bruge toArray()-metoden.

ArrayList<>-metoder

Lad os gennemgå de grundlæggende listemetoder. Indtil nu kunne du nemt have erstattet lister med arrays, men her er den væsentlige forskel—metoderne.

add()-metoden er en overloadet metode, hvilket betyder, at den har flere varianter. En af dem gør det muligt at tilføje et element på et bestemt indeks.

Når du indsætter et element midt i en liste, flyttes alle elementer til højre én position for at give plads til det nye element.

Hvis du for eksempel tilføjer et element i begyndelsen af listen, vil alle eksisterende elementer flytte én position til højre.

Lad os se på et eksempel:

Main.java


              123456789101112131415161718
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 0; i < 5; i++) { // Filling `numbers` list with 5 values
            numbers.add(i);
        }
        System.out.println("`numbers` before modifying: " + numbers);
        numbers.add(2, 10); // Adding 10 on the second index
        System.out.println("`numbers` after first modifying: " + numbers);
        numbers.add(0, 5);
        System.out.println("`numbers` after second modifying: " + numbers);
    }
}

Måden, hvorpå værdierne forskydes ved indsættelse af et element, kan visualiseres i følgende illustration:

Hentning af elementer

Hvis det er muligt at tilføje objekter til en liste på et bestemt indeks, er det naturligvis også muligt at hente objekter ved deres indeks ved hjælp af metoden get(int index).

Se følgende eksempel:

Main.java


              12345678910111213141516171819
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        names.add("David");
        names.add("Eva");

        // Retrieving element by index
        String element = names.get(2);  // Retrieving the 3rd element (index starts from 0)
        System.out.println("The element at index 2 is: " + element);
    }
}

Fjernelse af elementer

Du kan tilføje, du kan hente, men kan du slette? Selvfølgelig! Du kan fjerne elementer ved hjælp af metoden remove(int index).

Lad os skrive et program, der fjerner alle forekomster af denne studerende fra listen:

Main.java


              123456789101112131415161718
            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Charlie", "David", "Eva", "Frank", "Grace", "Hank", "Ivy", "Jack", "Katherine", "Leo", "Mia", "Nathan", "Olivia", "Paul", "Quinn", "Rachel", "Sam", "Tom", "Ursula", "Victor", "Wendy", "Xander", "Yvonne", "Zack", "Bob", "Emily", "Bob", "Jake", "Isabel", "Liam", "Nora", "Bob", "Sophia", "Bob", "Daniel", "Gabrielle", "Mike"};
        // Expelled student: Bob
        List<String> students = new ArrayList<>(Arrays.asList(names));
        System.out.println("Is Bob present in the list? " + students.contains("Bob"));
        while (students.contains("Bob")) {
            students.remove("Bob");
        }
        System.out.println("Is Bob still present in the list after the removal operation? " + students.contains("Bob"));
    }
}

Du har måske bemærket, at vi brugte en anden liste-metode—contains(Object obj). Denne metode kontrollerer, om det angivne element er til stede i listen, og returnerer true eller false.

Ved at bruge contains() sætter vi betingelsen for while-løkken, hvilket gør det muligt at fjerne alle forekomster af en studerende som "Bob" fra listen.

I øvrigt kan du forenkle denne proces betydeligt ved at bruge metoden removeAll(Collection<?> c):

Main.java


              123456789101112131415161718
            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Charlie", "David", "Eva", "Frank", "Grace", "Hank", "Ivy", "Jack", "Katherine", "Leo", "Mia", "Nathan", "Olivia", "Paul", "Quinn", "Rachel", "Sam", "Tom", "Ursula", "Victor", "Wendy", "Xander", "Yvonne", "Zack", "Bob", "Emily", "Bob", "Jake", "Isabel", "Liam", "Nora", "Bob", "Sophia", "Bob", "Daniel", "Gabrielle", "Mike"};
        // Expelled student: Bob
        List<String> students = new ArrayList<>(Arrays.asList(names));
        System.out.println("Is Bob present in the list? " + students.contains("Bob"));
        List<String> expelledStudents = new ArrayList<>();
        expelledStudents.add("Bob");
        students.removeAll(expelledStudents);
        System.out.println("Is Bob still present in the list after the removal operation? " + students.contains("Bob"));
    }
}

Metoden removeAll() tager en samling som parameter, der indeholder værdier, som vil blive fjernet fra listen, hvorpå metoden blev kaldt.

Opdatering af en værdi efter indeks

Lad os vende tilbage til liste-metoder—nu er det tid til opdateringsmetoden.

Da add()-metoden blot flytter alle elementer til højre ved indsættelse af en ny værdi, har vi brug for en anden måde til at opdatere en eksisterende værdi efter indeks.

Metoden set(int index, Object value) gør netop dette:

Main.java


              12345678910111213141516
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> example = new ArrayList<>();
        for (int i = 1; i <= 5; i++) {
            example.add(i);
        }
        System.out.println("List before modification: " + example);
        example.set(2, 28);
        System.out.println("List after modification: " + example);
    }
}

Det er ret ligetil—vi har erstattet elementet ved andet indeks med tallet 28.

Andre metoder

Du har allerede gennemgået de mest almindelige metoder, men der findes mange flere. Da de sjældent bruges, vil vi ikke fokusere på hver enkelt.

I stedet kan du finde alle de nødvendige metoder—sammen med fuldstændig dokumentation og detaljerede forklaringer—ved at åbne ArrayList-klassen i IntelliJ IDEA.

Var alt klart?

Tak for dine kommentarer!

Sektion 1. Kapitel 2

List og ArrayList i Java

ArrayList<>-metoder

Hentning af elementer

Fjernelse af elementer

Opdatering af en værdi efter indeks

Andre metoder

1. Hvilken metode kan vi bruge til at tilføje et element ved indeks?

2. Hvilken metode kan vi bruge til at hente et element ved indeks?

3. Hvilken metode kan vi bruge til at fjerne den første forekomst af et element?

4. Hvilken metode kan vi bruge til at erstatte et element via indeks?

5. Hvilken metode kan vi bruge til at kontrollere, om et element er til stede?

6. Kan vi oprette en liste ud fra et array?

7. Hvordan kan vi oprette en liste ud fra et array?

List og ArrayList i Java

ArrayList<>-metoder

Hentning af elementer

Fjernelse af elementer

Opdatering af en værdi efter indeks

Andre metoder

1. Hvilken metode kan vi bruge til at tilføje et element ved indeks?

2. Hvilken metode kan vi bruge til at hente et element ved indeks?

3. Hvilken metode kan vi bruge til at fjerne den første forekomst af et element?

4. Hvilken metode kan vi bruge til at erstatte et element via indeks?

5. Hvilken metode kan vi bruge til at kontrollere, om et element er til stede?

6. Kan vi oprette en liste ud fra et array?

7. Hvordan kan vi oprette en liste ud fra et array?