# Hvad er en Java-liste?

Java-lister er særligt velegnede til scenarier, hvor **størrelsen af et datasæt** ikke er klar fra starten, eller hvis størrelsen forventes at ændre sig over tid. Vi viser dig konkrete eksempler på, hvordan du bruger Java-lister, samt de operationer, du kan udføre med dem.

## Hvad kan Java-lister bruges til?

Lister er en af de grundlæggende datastrukturer i Java-programmering og kan bruges på mange forskellige måder. De indeholder elementer, der er arrangeret i en **bestemt rækkefølge**. Du kan tilføje, ændre, slette eller søge efter elementer i en liste. Java-lister kan indeholde objekter, der tilhører forskellige klasser. Det er også muligt at gemme duplikerede elementer eller null-elementer. Derudover understøtter Java-lister generiske klasser og metoder, hvilket sikrer typesikkerhed.

Lister kan bruges til databaseapplikationer. Her bruges de til at gemme og få adgang til **store datasæt fra databasesøgninger**. I grafiske brugergrænseflader bruges Java-lister ofte til at vise en liste over elementer, såsom valgmuligheder i en rullemenu eller forskellige varer i en onlinebutik.

Java-lister er også uundværlige i algoritmer og datastrukturer. De bruges i **sorteringsalgoritmer, søgealgoritmer og stak- og køstrukturer**. I netværksapplikationer kan lister hjælpe med at lette administrationen af forbindelser og sokler.

## Hvilke listemetoder har Java?

Java-lister tilhører Collection-grænsefladen og skal importeres fra pakken ***java.util***. Med [Java ArrayList](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-arraylist/), LinkedList, Vector og Stack er der forskellige implementeringsklasser, du kan vælge imellem. Du kan deklarere de forskellige forekomster af listerne med følgende kode:

```Java
List linkedList = new LinkedList(); // LinkedList
List arrayList = new ArrayList(); // ArrayList
List vecList = new Vector(); // Vector
List stackList = new Stack(); //Stack
```

Her er nogle af de vigtigste metoder, du kan bruge til Java-lister:

1. `int size()`: Bestemmer antallet af elementer i en liste
2. `void add(int index, E element)`: Tilføjer et element på en bestemt position
3. `boolean isEmpty()`: Kontrollerer, om en liste er tom
4. `void clear()`: Fjerner alle elementer fra en liste
5. `boolean contains(Object o)`: Returnerer værdien `true`, hvis objektet `o` er i listen
6. `boolean add(E e)`: Tilføjer et element til slutningen af en liste
7. `boolean remove(Object o)`: Fjerner det første forekomst af et element
8. `E get(int index)`: Erstat eller indsæt et element ved et angivet indeks
9. `E set(int index, E element)`: Erstat eller indsæt et element ved et angivet indeks
10. `Object[] toArray()`: Returnerer en matrix, der indeholder elementerne fra en liste
11. `List<E> subList(int fromIndex, int toIndex)`: Fanger alle elementer inden for det angivne interval
12. `default void replaceAll(UnaryOperator<E> operator)`: Standardmetode i Java 8, der anvender unære Java-operatorer på hvert element og derefter erstatter hvert element med resultatet af operationen.

## Sådan bruges Java-lister

Nedenfor viser vi almindelige metoder, der bruges, når man arbejder med Java-lister. Disse omfatter **konvertering af** arrays til lister og omvendt, samt sortering, hentning og ændring af elementer.

### Konverter en matrix til en liste

For at konvertere en matrix til en liste kan du gentage matrixen ved hjælp af sløjfer og tilføje elementerne til listen et ad gangen ved hjælp af metoden `add()`.

```Java
import java.util.*;
    public class ArrayToList{
      public static void main(String args[]){
      // Creating Array
      String[] colors={"blue","green","red","yellow"};
      System.out.println("Array: "+Arrays.toString(colors));
      //Converting Array to List
      List<String> list=new ArrayList<String>();
      for(String color: colors){
        list.add(color);
      }
      System.out.println("List: "+list);
      }
    }
```

Dette resulterer i følgende output:

```Java
Array: [blue, green, red, yellow]
List: [blue, green, red, yellow]
```

### Konverter en liste til en matrix

Med metode `toArray()` kan du konvertere en liste til en matrix:

```Java
import java.util.*;
    public class ListToArray{
      public static void main(String args[]){
       List<String> days = new ArrayList<String>();
       days.add("Monday");
       days.add("Tuesday");
       days.add("Wednesday");
       days.add("Thursday");
       days.add("Friday");
       days.add("Saturday");
       days.add("Sunday");
       // Converting ArrayList to Array
       String[] array = days.toArray(new String[days.size()]);
       System.out.println("Array: "+Arrays.toString(array));
       System.out.println("List: "+days);
      }
    }
```

I outputtet kan du se, at elementerne i arrayet og listen er identiske:

```Java
Array: [Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday]
List: [Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday]
```

### Opkald og ændring af elementer i en Java-liste

Med metoden `get()` kan du få adgang til et element ved et bestemt indeks. Metoden `set()` giver dig mulighed for **at erstatte et element med et andet element** på en bestemt position i listen.

```Java
import java.util.*;
    public class ListExample{
      public static void main(String args[]){
      // Creating a List
      List<String> letters=new ArrayList<String>();
      // Adding elements
      letters.add("a");
      letters.add("b");
      letters.add("c");
      // get()
      System.out.println("Element at index 1: "+letters.get(1));
      // set()
      letters.set(2, "d");
      for(String letter: letters)
      System.out.println(letter);
      }
    }
```

Da tællingen i Java starter med indeks 0, får vi følgende resultat:

```Java
Element at index 1: b
a
b
d
```

### Sorter en liste

Du kan sortere en Java-liste ved hjælp af metoden `.sort()` fra klassen Collections. Du kan gennemløbe listen ved hjælp af en løkke og udskrive elementerne til konsollen et efter et:

```Java
import java.util.*;
    class SortArrayList{
      public static void main(String args[]){
      // Creating a list of numbers
      List<Integer> numbers=new ArrayList<Integer>();
      numbers.add(4);
      numbers.add(57);
      numbers.add(92);
      numbers.add(26);
      // Sorting
      Collections.sort(numbers);
      for(Integer number: numbers)
        System.out.println(number);
      }
    }
```

Tallene i Java-listen vises på skærmen fra det mindste til det største:

```Java
4
26
57
92
```


This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-liste/](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-liste/) for AI/LLM consumption.