# Hva er en Java-liste?

Java-lister er spesielt egnet for scenarier hvor **størrelsen på et datasett** ikke er klart fra starten av, eller hvis størrelsen forventes å endre seg over tid. Vi viser deg konkrete eksempler på hvordan du bruker Java-lister, samt operasjonene du kan utføre med dem.

## Hva kan Java-lister brukes til?

Lister er en av de grunnleggende datastrukturene i Java-programmering og kan brukes på mange forskjellige måter. De inneholder elementer som er ordnet i en **bestemt rekkefølge**. Du kan legge til, endre, slette eller søke etter elementer i en liste. Java-lister kan inneholde objekter som tilhører forskjellige klasser. Det er også mulig å lagre dupliserte elementer eller null-elementer. I tillegg støtter Java-lister generiske klasser og metoder, noe som sikrer typesikkerhet.

Lister kan brukes til databaseapplikasjoner. Her brukes de til å lagre og få tilgang til **store datasett fra databasesøk**. I grafiske brukergrensesnitt brukes Java-lister ofte til å vise en liste over elementer, for eksempel alternativer i en rullegardinmeny eller ulike varer i en nettbutikk.

Java-lister er også uunnværlige i algoritmer og datastrukturer. De brukes i **sorteringsalgoritmer, søkealgoritmer og stakk- og køstrukturer**. I nettverksapplikasjoner kan lister bidra til å forenkle administrasjonen av tilkoblinger og sokler.

## Hvilke listemetoder har Java?

Java-lister tilhører Collection-grensesnittet og må importeres fra pakken ***java.util***. Med [Java ArrayList](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-arraylist/), LinkedList, Vector og Stack finnes det ulike implementeringsklasser du kan velge mellom. Du kan deklarere de ulike instansene av listene 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 noen av de viktigste metodene du kan bruke for Java-lister:

1. `int size()`: Bestemmer antall elementer i en liste
2. `void add(int index, E element)`: Legger til et element på en bestemt posisjon
3. `boolean isEmpty()`: Sjekker om en liste er tom
4. `void clear()`: Fjerner alle elementer fra en liste
5. `boolean contains(Object o)`: Returnerer verdien `true` hvis objektet `o` er i listen
6. `boolean add(E e)`: Legger til et element på slutten av en liste
7. `boolean remove(Object o)`: Fjerner det første forekomsten av et element
8. `E get(int index)`: Erstatt eller sett inn et element på en spesifisert indeks
9. `E set(int index, E element)`: Erstatt eller sett inn et element ved en spesifisert indeks
10. `Object[] toArray()`: Returnerer en matrise som inneholder elementene fra en liste
11. `List<E> subList(int fromIndex, int toIndex)`: Fanger opp alle elementene innenfor det angitte intervallet
12. `default void replaceAll(UnaryOperator<E> operator)`: Standardmetode i Java 8 som bruker unaire Java-operatorer på hvert element og deretter erstatter hvert element med resultatet fra operasjonen.

## Hvordan bruke Java-lister

Nedenfor viser vi vanlige metoder som brukes når man arbeider med Java-lister. Disse inkluderer **konvertering av** matriser til lister og omvendt, samt sortering, henting og endring av elementer.

### Konverter en matrise til en liste

For å konvertere en matrise til en liste kan du iterere gjennom matrisen ved hjelp av løkker og legge elementene til listen ett etter ett ved hjelp av 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 gir følgende utdata:

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

### Konverter en liste til en matrise

Med metoden `toArray()` kan du konvertere en liste til en matrise:

```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 utdataene kan du se at elementene i matrisen og listen er identiske:

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

### Ring og endre elementer i en Java-liste

Med metoden `get()` kan du få tilgang til et element ved en bestemt indeks. Metoden `set()` lar deg **erstatte et element med et annet element** på en spesifisert posisjon 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);
      }
    }
```

Siden telling i Java starter med indeksen 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 hjelp av metoden `.sort()` fra klassen Collections. Du kan gå gjennom listen ved hjelp av en løkke og skrive ut elementene til konsollen ett etter ett:

```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å skjermen fra minste til største:

```Java
4
26
57
92
```


This is a markdown version of: [https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-liste/](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-liste/) for AI/LLM consumption.