# Hvordan bruke Java ArrayList

**ArrayList** er en av de mest brukte datastrukturene i Java. Den lar deg dynamisk endre og lagre en samling av objekter. I denne veiledningen introduserer vi deg for syntaksen til Java ArrayList og forklarer når du bør bruke den.

## Hva er forskjellen mellom ArrayList og Array i Java?

Java ArrayList er dynamisk, noe som betyr at den vokser og krymper i størrelse når elementer legges til eller fjernes. Det er verdt å merke seg at ArrayList-klassen er en del av **Java Collections Framework** og ikke er tilgjengelig som standard. I motsetning til matriser må den importeres fra *java.util-biblioteket*.

ArrayLists er et godt valg når lengden på en [Java List](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-liste/) kan variere. Eksempler er lagring av objekter, **søking eller sortering av** data og oppretting av lister eller køer.

Derimot er det ikke mulig å endre størrelsen på en matrise. Dette betyr at du ideelt sett bør vite på forhånd hvor mange objekter matrisen skal inneholde. Matriser er egnet for å håndtere et forhåndsdefinert sett med **primitive datatyper** som int, float, char eller Boolean.

En ulempe med ArrayLists er at det kan **ta lengre tid å få tilgang til dem**. Mens arrays har en fast, sammenhengende minneblokk, lagres ikke objekter i ArrayLists sammenhengende. Det er viktig å ta hensyn til fordelene og ulempene ved datastrukturene, slik at du kan velge den som passer best for ditt bruksområde.

## Hva er syntaksen for Java ArrayList?

Før du oppretter ArrayList, må den tilsvarende klassen importeres fra *java.util* -biblioteket.

```Java
import java.util.ArrayList;
```

Den generelle syntaksen er:

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

«Type» står for den respektive datatypen i Java ArrayList.

Det neste trinnet er å lage lister med `strings` og `integers`.

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

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

ArrayLists bruker den tilsvarende **wrapper-klassen** for primitive datatyper, slik at de behandles som objekter. Dette betyr at du må spesifisere `integer` i stedet for `int`.

## Eksempler på Java ArrayList-metoder

Operasjoner som å legge til eller fjerne elementer utføres ikke på ArrayLists med Java-operatorer, men via **forhåndsdefinerte metoder**. Nedenfor viser vi deg de vanligste ArrayList-metodene.

### Legge til elementer

Etter å ha opprettet ArrayList «colours» (`String` type), legger vi til ulike elementer ved hjelp av metoden `.add()`.

```Java
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);
    }
}
```

Dette resulterer i:

```Java
ArrayList: [blue, red, green]
```

### Fjerne elementer

For å fjerne objekter fra Java ArrayList bruker vi metoden `.remove()` og angir elementets indeks.

```Java
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);
    }
}
```

Utdataene viser den endrede ArrayList og elementet som er fjernet:

```Java
ArrayList: [blue, green]
Removed Element: red
```

Som med de fleste programmeringsspråk starter telling i Java fra 0. Dette betyr at det fjernede elementet ved indeks 1 er `red`.

### Tilgang til elementer i Java ArrayList

Ved hjelp av funksjonen `.get()` kan vi få tilgang til et element på en bestemt posisjon.

```Java
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);
    }
}
```

For utdataen får vi:

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

### Endring av elementer

Med `.set()` kan vi endre et element ved å tilordne et nytt element til en bestemt indeks.

```Java
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);
    }
}
```

Vi ser nå `yellow` i stedet for `green` på indeks 2:

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

### Bestemme lengden på Java ArrayList

Antall elementer i ArrayList kan enkelt beregnes ved hjelp av metoden `.size()`.

```Java
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());
    }
}
```

Dette er resultatet:

```Java
3
```

### Sortering og iterasjon gjennom ArrayList

For å sortere Java ArrayList må samlingsklassen importeres. For iterasjonen bruker vi en [Java for-each-sløyfe](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-for-hver-loekke/). For hver iterasjon av sløyfen sendes det respektive elementet til konsollen.

```Java
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);
        }
    }
}
```

Elementene i ArrayList vises fra minste til største:

```Java
9
17
20
54
```


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